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_types = ["eeg"] * 59 + ["misc"] + 3 * ["eeg"] + ["misc", "stim"] sfreq = 250 info = create_info(self._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): """Return the data of a single subject""" n_samples, n_channels, n_trials = 1114, 8, 15 n_classes = len(self.event_id) fname = self.data_path(subject) mat = loadmat(fname, squeeze_me=True) data = np.transpose(mat["eeg"], axes=(0, 3, 1, 2)) 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 = [ "PO7", "PO3", "POz", "PO4", "PO8", "O1", "Oz", "O2", "stim" ] ch_types = ["eeg"] * 8 + ["stim"] sfreq = 256 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 load_raw(filename, sfreq=256., ch_ind=[0, 1, 2, 3], stim_ind=5, replace_ch_names=None): ''' [!] FUNCIÓN de creación del objeto Raw a partir del fichero con los datos del experimento. ''' n_channel = len(ch_ind) data = pd.read_csv(filename) if "Timestamp" in data.columns: del data['Timestamp'] if "Time" in data.columns: del data['Time'] ch_names = list(data.columns)[0:n_channel] + ['Stim'] if replace_ch_names is not None: ch_names = [ c if c not in replace_ch_names.keys() else replace_ch_names[c] for c in ch_names ] ch_types = ['eeg'] * n_channel + ['stim'] # montage = read_custom_montage('openbcipos.sfp') montage = 'standard_1020' data = data.values[:, ch_ind + [stim_ind]].T data[:-1] *= 1e-6 info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=data, info=info) raw.set_montage(montage) return raw
def _get_single_subject_data(self, subject: Union[str, int], verbose: Optional[Union[bool, str, int]] = None) -> Dict[str, Dict[str, Raw]]: montage = make_standard_montage('standard_1005') montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names] dests = self.data_path(subject) raw_mat = loadmat(dests[0][0]) n_samples, n_channels, n_trials = 1114, 8, 15 n_classes = 12 data = np.transpose(raw_mat['eeg'], axes=(0, 3, 1, 2)) 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) buff = (data.shape[0], n_channels + 1, 50) data = np.concatenate([np.zeros(buff), data, np.zeros(buff)], axis=2) ch_names = self._CHANNELS + ['stim'] ch_types = ['eeg']*len(self._CHANNELS) + ['stim'] info = create_info( ch_names=ch_names, ch_types=ch_types, sfreq=self.srate ) raw = RawArray(data=np.concatenate(list(data), axis=1), info=info) raw = upper_ch_names(raw) raw.set_montage(montage) sess = { 'session_0': {'run_0': raw} } return sess
def _get_single_subject_data(self, subject: int): record = self.read_hdf(self.data_path(subject)) info = create_info( self.ch_names + ["mult_target", "target"], self.sampling_rate, ["eeg"] * len(self.ch_names) + ["misc", "stim"], ) montage = make_standard_montage("standard_1020") runs_raw = {} for i, act in enumerate(record): # target and stims are increased by 1 # because the channel is filled with zeros by default target = act["target"] + 1 run_data = [] for eeg, starts, stims in act["sessions"]: starts = starts * self.sampling_rate / self._ms_in_sec starts = starts.round().astype(np.int) stims = stims + 1 stims_channel = np.zeros(eeg.shape[1]) target_channel = np.zeros(eeg.shape[1]) for start, stimul in zip(starts, stims): stims_channel[start] = stimul target_channel[start] = 1 if stimul == target else 2 round_data = np.vstack( (eeg, stims_channel[None, :], target_channel[None, :])) run_data.append(round_data) raw = RawArray(np.hstack(run_data), info) raw.set_montage(montage) runs_raw[f"run_{i}"] = raw return {"session_0": runs_raw}
def _convert_run(run, ch_names=None, ch_types=None, verbose=None): """Convert one run to raw.""" # parse eeg data event_id = {} n_chan = run.X.shape[1] montage = make_standard_montage('standard_1005') eeg_data = 1e-6 * run.X sfreq = run.fs if not ch_names: ch_names = ['EEG%d' % ch for ch in range(1, n_chan + 1)] montage = None # no montage if not ch_types: ch_types = ['eeg'] * n_chan trigger = np.zeros((len(eeg_data), 1)) # some runs does not contains trials i.e baseline runs if len(run.trial) > 0: trigger[run.trial - 1, 0] = run.y else: return None, None eeg_data = np.c_[eeg_data, trigger] ch_names = ch_names + ['stim'] ch_types = ch_types + ['stim'] event_id = {ev: (ii + 1) for ii, ev in enumerate(run.classes)} info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=eeg_data.T, info=info, verbose=verbose) raw.set_montage(montage) return raw, event_id
def _convert_run_bbci(run, ch_types, verbose=None): """Convert one run to raw.""" # parse eeg data montage = make_standard_montage('standard_1005') eeg_data = 1e-6 * run.X sfreq = run.fs ch_names = list(run.channels) trigger = np.zeros((len(eeg_data), 1)) trigger[run.trial - 1, 0] = run.y event_id = {ev: (ii + 1) for ii, ev in enumerate(run.classes)} flash = np.zeros((len(eeg_data), 1)) flash[run.trial - 1, 0] = run.y_stim + 2 ev_fl = {'Stim%d' % (stim): (stim + 2) for stim in np.unique(run.y_stim)} event_id.update(ev_fl) eeg_data = np.c_[eeg_data, trigger, flash] ch_names = ch_names + ['Target', 'Flash'] ch_types = ch_types + ['stim'] * 2 info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=eeg_data.T, info=info, verbose=verbose) raw.set_montage(montage) return raw, event_id
def _convert_to_raw(self, data, s): fs = 500 ch_names = [ 'Fp1', 'F5', 'F3', 'F1', 'Fz', 'FC5', 'FC3', 'FC1', 'FCz', 'C5', 'C3', 'C1', 'Cz', 'CP5', 'CP3', 'CP1', 'CPz', 'P5', 'P3', 'P1', 'Pz' ] ch_types = ['eeg'] * 21 info = create_info(ch_names, fs, ch_types) info['description'] = 'PGHealthy' x = data['Signals'] * 1e-6 raw = RawArray(x, info) epoch_start = np.array(data['Epoch_start']).T N = len(epoch_start) events = np.c_[epoch_start, np.zeros(N), np.ones(N) * (s + 1)] events = events.astype(np.int) raw.set_montage('standard_1005') mapping = {v: k for k, v in self.event_id.items()} onsets = events[:, 0] / raw.info['sfreq'] durations = np.zeros_like(onsets) # assumes instantaneous events descriptions = [mapping[ev_id] for ev_id in events[:, 2]] annot_from_events = Annotations(onset=onsets, duration=durations, description=descriptions) raw.notch_filter(50, verbose=False) return raw.set_annotations(annot_from_events)
def _convert_run_epfl(run, verbose=None): """Convert one run to raw.""" # parse eeg data event_id = {} montage = make_standard_montage('standard_1005') eeg_data = 1e-6 * run.eeg sfreq = run.header.SampleRate ch_names = list(run.header.Label[:-1]) ch_types = ['eeg'] * len(ch_names) trigger = np.zeros((len(eeg_data), 1)) for ii, typ in enumerate(run.header.EVENT.TYP): if typ in [6, 9]: # Error trigger[run.header.EVENT.POS[ii] - 1, 0] = 2 elif typ in [5, 10]: # correct trigger[run.header.EVENT.POS[ii] - 1, 0] = 1 eeg_data = np.c_[eeg_data, trigger] ch_names = ch_names + ['stim'] ch_types = ch_types + ['stim'] event_id = {'correct': 1, 'error': 2} info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=eeg_data.T, info=info, verbose=verbose) raw.set_montage(montage) return raw, event_id
def _get_single_subject_data(self, subject): """return data for a single subject""" fnames = self.data_path(subject) sessions = {} for fpath in fnames: if self.code == "SSVEP MAMEM3": fnamed = os.path.basename(fpath) session_name = "session_" + fnamed[4] # Since the data for each session is saved in 2 files, # it is being saved in 2 runs run_number = len(fnamed) - 6 run_name = "run_" + str(run_number) else: session_name = "session_" + fpath[-1] run_name = "run_0" record = wfdb.rdrecord(fpath) data = record.p_signal.T annots = wfdb.rdann(fpath, "win") # the number of samples isn't exactly equal in all the trials n_samples = record.sig_len stim_freq = np.array([float(e) for e in self.event_id.keys()]) # aux_note are the exact frequencies, matched to nearest class events_label = [ np.argmin(np.abs(stim_freq - float(f))) + 1 for f in annots.aux_note ] raw_events = np.zeros([1, n_samples]) # annots.sample indicates the start of the trial # of class "events_label" for label, samploc in zip(events_label, annots.sample): raw_events[0, samploc] = label # append the data as another channel(stim) in the data data = np.concatenate((data, raw_events), axis=0) if self.code == "SSVEP MAMEM3": ch_names = record.sig_name sfreq = 128 montage = make_standard_montage("standard_1020") else: ch_names = ["E{}".format(i + 1) for i in range(0, 256)] # ch_names = ["{}-{}".format(s, i) if s == "EEG" else s # for i, s in enumerate(record.sig_name)] sfreq = 250 montage = make_standard_montage("GSN-HydroCel-256") ch_types = ["eeg"] * len(ch_names) + ["stim"] ch_names.append("stim") info = create_info(ch_names, sfreq, ch_types) raw = RawArray(data, info, verbose=False) raw.set_montage(montage) if session_name not in sessions.keys(): sessions[session_name] = {} if len(sessions[session_name]) == 0: sessions[session_name] = {run_name: raw} else: sessions[session_name][run_name] = raw return sessions
def load_openBCI_csv_as_raw( filename, sfreq=256., ch_ind=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], stim_ind=16, replace_ch_names=None, verbose=1): """Load CSV files into a Raw object. Args: filename (list): paths to CSV files to load Keyword Args: subject_nb (int or str): subject number. If 'all', load all subjects. session_nb (int or str): session number. If 'all', load all sessions. sfreq (float): EEG sampling frequency ch_ind (list): indices of the EEG channels to keep stim_ind (int): index of the stim channel replace_ch_names (dict or None): dictionary containing a mapping to rename channels. Useful when an external electrode was used. Returns: (mne.io.array.array.RawArray): loaded EEG """ n_channel = len(ch_ind) raw = [] for fname in filename: # read the file data = pd.read_csv(fname, index_col=0) # name of each channels ch_names = list(data.columns)[0:n_channel] + ['Stim'] if replace_ch_names is not None: ch_names = [ c if c not in replace_ch_names.keys() else replace_ch_names[c] for c in ch_names ] # type of each channels ch_types = ['eeg'] * n_channel + ['stim'] # get data and exclude Aux channel data = data.values[:, ch_ind + [stim_ind]].T # convert in Volts (from nanoVolts?) data[:-1] *= 1e-9 montage = make_standard_montage('standard_1005') info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq, verbose=verbose) rawi = RawArray(data=data, info=info, verbose=verbose) rawi.set_montage(montage, raise_if_subset=False, match_case=False) raw.append(rawi) # concatenate all raw objects raws = concatenate_raws(raw, verbose=verbose) return raws
def _load_data_003_2015(subject, path=None, force_update=False, update_path=None, base_url=BNCI_URL, verbose=None): """Load data for 003-2015 dataset.""" if (subject < 1) or (subject > 10): raise ValueError("Subject must be between 1 and 12. Got %d." % subject) url = '{u}003-2015/s{s:d}.mat'.format(u=base_url, s=subject) filename = data_path(url, path, force_update, update_path)[0] from scipy.io import loadmat data = loadmat(filename, struct_as_record=False, squeeze_me=True) data = data['s%d' % subject] sfreq = 256. ch_names = [ 'Fz', 'Cz', 'P3', 'Pz', 'P4', 'PO7', 'Oz', 'PO8', 'Target', 'Flash' ] ch_types = ['eeg'] * 8 + ['stim'] * 2 montage = make_standard_montage('standard_1005') info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) sessions = {} sessions['session_0'] = {} for ri, run in enumerate([data.train, data.test]): # flash events on the channel 9 flashs = run[9:10] ix_flash = flashs[0] > 0 flashs[0, ix_flash] += 2 # add 2 to avoid overlapp on event id flash_code = np.unique(flashs[0, ix_flash]) if len(flash_code) == 36: # char mode evd = {'Char%d' % ii: (ii + 2) for ii in range(1, 37)} else: # row / column mode evd = {'Col%d' % ii: (ii + 2) for ii in range(1, 7)} evd.update({'Row%d' % ii: (ii + 8) for ii in range(1, 7)}) # target events are on channel 10 targets = np.zeros_like(flashs) targets[0, ix_flash] = run[10, ix_flash] + 1 eeg_data = np.r_[run[1:-2] * 1e-6, targets, flashs] raw = RawArray(data=eeg_data, info=info, verbose=verbose) raw.set_montage(montage) sessions['session_0']['run_' + str(ri)] = raw return sessions
def _load_data_003_2015( subject, path=None, force_update=False, update_path=None, base_url=BNCI_URL, verbose=None, ): """Load data for 003-2015 dataset.""" if (subject < 1) or (subject > 10): raise ValueError("Subject must be between 1 and 12. Got %d." % subject) url = "{u}003-2015/s{s:d}.mat".format(u=base_url, s=subject) filename = data_path(url, path, force_update, update_path)[0] data = loadmat(filename, struct_as_record=False, squeeze_me=True) data = data["s%d" % subject] sfreq = 256.0 ch_names = [ "Fz", "Cz", "P3", "Pz", "P4", "PO7", "Oz", "PO8", "Target", "Flash" ] ch_types = ["eeg"] * 8 + ["stim"] * 2 montage = make_standard_montage("standard_1005") info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) sessions = {} sessions["session_0"] = {} for ri, run in enumerate([data.train, data.test]): # flash events on the channel 9 flashs = run[9:10] ix_flash = flashs[0] > 0 flashs[0, ix_flash] += 2 # add 2 to avoid overlapp on event id flash_code = np.unique(flashs[0, ix_flash]) if len(flash_code) == 36: # char mode evd = {"Char%d" % ii: (ii + 2) for ii in range(1, 37)} else: # row / column mode evd = {"Col%d" % ii: (ii + 2) for ii in range(1, 7)} evd.update({"Row%d" % ii: (ii + 8) for ii in range(1, 7)}) # target events are on channel 10 targets = np.zeros_like(flashs) targets[0, ix_flash] = run[10, ix_flash] + 1 eeg_data = np.r_[run[1:-2] * 1e-6, targets, flashs] raw = RawArray(data=eeg_data, info=info, verbose=verbose) raw.set_montage(montage) sessions["session_0"]["run_" + str(ri)] = raw return sessions
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)
def _get_single_subject_data(self, subject): """return data for a single subejct""" sessions = {} file_path_list = self.data_path(subject) for session in range(1, 3): data = loadmat(file_path_list[session - 1]) # Create channel info and montage eeg_ch_names = data["EEG_MI_train"][0, 0][8][0] ch_names = [elem[0] for elem in eeg_ch_names] + ["stim"] ch_types = ["eeg"] * 62 + ["stim"] sfreq = data["EEG_MI_train"][0, 0][3][0, 0] info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) montage = make_standard_montage("standard_1005") # Create raw_data raw_train_data = np.transpose(data["EEG_MI_train"][0, 0][0], (1, 2, 0)) raw_test_data = np.transpose(data["EEG_MI_test"][0, 0][0], (1, 2, 0)) raw_data = np.concatenate([raw_train_data, raw_test_data], axis=0) # Create raw_event train_event_id = data["EEG_MI_train"][0, 0][4].ravel() test_event_id = data["EEG_MI_test"][0, 0][4].ravel() event_id = np.concatenate([train_event_id, test_event_id], axis=0) raw_events = np.zeros((raw_data.shape[0], 1, raw_data.shape[2])) raw_events[:, 0, 0] = event_id # Zero pad the data data = np.concatenate([raw_data, raw_events], axis=1) zeroshape = (data.shape[0], data.shape[1], 50) data = np.concatenate( [np.zeros(zeroshape), data, np.zeros(zeroshape)], axis=2) # Create RawArray raw = RawArray(data=np.concatenate(list(data), axis=1), info=info, verbose=False) raw.set_montage(montage) # add the data to sessions session_name = "session_{}".format(session) sessions[session_name] = {"run_1": raw} return sessions
def _convert_one_session(self, data, mrk, session, trig_offset=0): eeg = data[session].x.T * 1e-6 trig = np.zeros((1, eeg.shape[1])) idx = (mrk[session].time - 1) // 5 trig[0, idx] = mrk[session].event.desc // 16 + trig_offset eeg = np.vstack([eeg, trig]) ch_names = list(data[session].clab) + ['Stim'] ch_types = ['eeg'] * 30 + ['eog'] * 2 + ['stim'] montage = make_standard_montage('standard_1005') info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=200.) raw = RawArray(data=eeg, info=info, verbose=False) raw.set_montage(montage) return {'run_0': raw}
def _get_single_subject_data(self, subject): """return data for a single subject""" fnames = self.data_path(subject) filelist = fs_get_file_list(self.figshare_id) fsn = fs_get_file_name(filelist) sessions = {} for fpath in fnames: fnamed = fsn[osp.basename(fpath)] if fnamed[4] == "x": continue session_name = "session_" + fnamed[4] if self.code == "SSVEP MAMEM3": # Since the data for each session is saved in 2 files, # it is being saved in 2 runs run_number = len(fnamed) - 10 run_name = "run_" + str(run_number) else: run_name = "run_0" if self.code == "SSVEP MAMEM3": m = loadmat(fpath) ch_names = [e[0] for e in m["info"][0, 0][9][0]] sfreq = 128 montage = make_standard_montage("standard_1020") eeg = m["eeg"] else: m = loadmat(fpath, squeeze_me=True) ch_names = ["E{}".format(i + 1) for i in range(0, 256)] ch_names.append("stim") # ch_names = ["{}-{}".format(s, i) if s == "EEG" else s # for i, s in enumerate(record.sig_name)] sfreq = 250 if self.code == "SSVEP MAMEM2": labels = m["labels"] else: labels = None eeg = mamem_event(m["eeg"], m["DIN_1"], labels=labels) montage = make_standard_montage("GSN-HydroCel-256") ch_types = ["eeg"] * (len(ch_names) - 1) + ["stim"] info = create_info(ch_names, sfreq, ch_types) raw = RawArray(eeg, info, verbose=False) raw.set_montage(montage) if session_name not in sessions.keys(): sessions[session_name] = {} if len(sessions[session_name]) == 0: sessions[session_name] = {run_name: raw} else: sessions[session_name][run_name] = raw return sessions
def _get_single_subject_data(self, subject): """return data for a single subject""" fname = self.data_path(subject) data = loadmat( fname, squeeze_me=True, struct_as_record=False, verify_compressed_data_integrity=False, )["eeg"] # fmt: off eeg_ch_names = [ "Fp1", "AF7", "AF3", "F1", "F3", "F5", "F7", "FT7", "FC5", "FC3", "FC1", "C1", "C3", "C5", "T7", "TP7", "CP5", "CP3", "CP1", "P1", "P3", "P5", "P7", "P9", "PO7", "PO3", "O1", "Iz", "Oz", "POz", "Pz", "CPz", "Fpz", "Fp2", "AF8", "AF4", "AFz", "Fz", "F2", "F4", "F6", "F8", "FT8", "FC6", "FC4", "FC2", "FCz", "Cz", "C2", "C4", "C6", "T8", "TP8", "CP6", "CP4", "CP2", "P2", "P4", "P6", "P8", "P10", "PO8", "PO4", "O2", ] # fmt: on emg_ch_names = ["EMG1", "EMG2", "EMG3", "EMG4"] ch_names = eeg_ch_names + emg_ch_names + ["Stim"] ch_types = ["eeg"] * 64 + ["emg"] * 4 + ["stim"] montage = make_standard_montage("standard_1005") imagery_left = data.imagery_left - data.imagery_left.mean(axis=1, keepdims=True) imagery_right = data.imagery_right - data.imagery_right.mean( axis=1, keepdims=True ) eeg_data_l = np.vstack([imagery_left * 1e-6, data.imagery_event]) eeg_data_r = np.vstack([imagery_right * 1e-6, data.imagery_event * 2]) # trials are already non continuous. edge artifact can appears but # are likely to be present during rest / inter-trial activity eeg_data = np.hstack( [eeg_data_l, np.zeros((eeg_data_l.shape[0], 500)), eeg_data_r] ) log.warning( "Trials demeaned and stacked with zero buffer to create " "continuous data -- edge effects present" ) info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=data.srate) raw = RawArray(data=eeg_data, info=info, verbose=False) raw.set_montage(montage) return {"session_0": {"run_0": raw}}
def test_pick_types_csd(): """Test pick_types(csd=True).""" # info with laplacian/CSD channels at indices 1, 2 names = ['F1', 'F2', 'C1', 'C2', 'A1', 'A2', 'misc1', 'CSD1'] info1 = create_info( names, 256, ["eeg", "eeg", "eeg", "eeg", "mag", "mag", 'misc', 'csd']) raw = RawArray(np.zeros((8, 512)), info1) raw.set_montage(make_standard_montage('standard_1020'), verbose='error') raw_csd = compute_current_source_density(raw, verbose='error') assert_array_equal(pick_types(info1, csd=True), [7]) # pick from the raw object assert raw_csd.copy().pick_types(csd=True).ch_names == [ 'F1', 'F2', 'C1', 'C2', 'CSD1' ]
def _convert_run_p300_sl(run, verbose=None): """Convert one p300 run from santa lucia file format.""" montage = make_standard_montage('standard_1005') eeg_data = 1e-6 * run.X sfreq = 256 ch_names = list(run.channels) + ['Target stim', 'Flash stim'] ch_types = ['eeg'] * len(run.channels) + ['stim'] * 2 flash_stim = run.y_stim flash_stim[flash_stim > 0] += 2 eeg_data = np.c_[eeg_data, run.y, flash_stim] event_id = {ev: (ii + 1) for ii, ev in enumerate(run.classes)} event_id.update({ev: (ii + 3) for ii, ev in enumerate(run.classes_stim)}) info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=sfreq) raw = RawArray(data=eeg_data.T, info=info, verbose=verbose) raw.set_montage(montage) return raw, event_id
def _get_single_subject_data(self, subject): """return data for a single subject""" fname = self.data_path(subject) data = loadmat(fname, squeeze_me=True, struct_as_record=False, verify_compressed_data_integrity=False)['eeg'] eeg_ch_names = [ 'Fp1', 'AF7', 'AF3', 'F1', 'F3', 'F5', 'F7', 'FT7', 'FC5', 'FC3', 'FC1', 'C1', 'C3', 'C5', 'T7', 'TP7', 'CP5', 'CP3', 'CP1', 'P1', 'P3', 'P5', 'P7', 'P9', 'PO7', 'PO3', 'O1', 'Iz', 'Oz', 'POz', 'Pz', 'CPz', 'Fpz', 'Fp2', 'AF8', 'AF4', 'AFz', 'Fz', 'F2', 'F4', 'F6', 'F8', 'FT8', 'FC6', 'FC4', 'FC2', 'FCz', 'Cz', 'C2', 'C4', 'C6', 'T8', 'TP8', 'CP6', 'CP4', 'CP2', 'P2', 'P4', 'P6', 'P8', 'P10', 'PO8', 'PO4', 'O2' ] emg_ch_names = ['EMG1', 'EMG2', 'EMG3', 'EMG4'] ch_names = eeg_ch_names + emg_ch_names + ['Stim'] ch_types = ['eeg'] * 64 + ['emg'] * 4 + ['stim'] montage = make_standard_montage('standard_1005') imagery_left = data.imagery_left - \ data.imagery_left.mean(axis=1, keepdims=True) imagery_right = data.imagery_right - \ data.imagery_right.mean(axis=1, keepdims=True) eeg_data_l = np.vstack([imagery_left * 1e-6, data.imagery_event]) eeg_data_r = np.vstack([imagery_right * 1e-6, data.imagery_event * 2]) # trials are already non continuous. edge artifact can appears but # are likely to be present during rest / inter-trial activity eeg_data = np.hstack( [eeg_data_l, np.zeros((eeg_data_l.shape[0], 500)), eeg_data_r]) log.warning("Trials demeaned and stacked with zero buffer to create " "continuous data -- edge effects present") info = create_info(ch_names=ch_names, ch_types=ch_types, sfreq=data.srate) raw = RawArray(data=eeg_data, info=info, verbose=False) raw.set_montage(montage) return {'session_0': {'run_0': 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 = 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_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) raw = RawArray(np.zeros((1, 1000)), 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]) raw.set_montage(mon) with pytest.raises(ValueError, match='match_case=False as 1 montage name'): raw.set_montage(mon, match_case=False)
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: 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 _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: 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 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 create_raw_with_noise(raw_without_noise, gaussian_distribution=None): ''' [!] FUNCIÓN para hacer una copia de un Raw Data, aplicarle ruido y devolverlo como estructura Raw. ''' data = raw_without_noise.get_data() stim = raw_without_noise.get_data(picks=['Stim']) ''' Se crean muestras parametrizadas de una distribución normal (gaussiana) para generar ruido en la señal ''' if len(data) == len(gaussian_distribution): print("Aplicando ruido a la señal...") data = data + gaussian_distribution data[-1] = stim else: print( "Error en la aplicación de ruido. Estructuras de datos con tamaños distintos." ) return raw = RawArray(data=data, info=raw_without_noise.info) montage = 'standard_1020' raw.set_montage(montage) return raw
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