Ejemplo n.º 1
0
montage = mne.channels.read_montage('biosemi128')
raw.set_montage(montage)
# mne.viz.plot_sensors(raw.info)

# Bad channels
bads = bad_channs[subj]
raw.info['bads'] = bads
picks_eeg = mne.pick_types(raw.info, eeg=True, meg=False, eog=False, exclude='bads')
# raw.plot(n_channels=128)

# Log
log = read_log_file(log_filename)

# Events
events = mne.find_events(raw)
events = check_events(events)
durations = durations_from_log(log)
new_events = create_events(events, durations, fs)
raw.add_events(new_events)
events_updated = mne.find_events(raw, shortest_event=1)
# mne.viz.plot_events(events_updated)

# Reject
reject = {'eeg': 120e-6}

if do_ica:
    n_components = 20
    method = 'fastica'
    decim = 3
    ica = mne.preprocessing.ICA(n_components=n_components, method=method)
    ica.fit(raw, picks=picks_eeg, decim=decim, reject=reject)
Ejemplo n.º 2
0
        53,
        54,
        55
    ]

# Filters
notchs = np.arange(50, 151, 50)
raw.filter(l_freq=1, h_freq=140, n_jobs=n_jobs)
raw.notch_filter(freqs=notchs, n_jobs=n_jobs)

# Log
log_filename = log_path + 'ETG{}a_{}.mat'.format(ratios, subj)
log = read_log_file(log_filename)

events = mne.find_events(raw)
events = check_events(events)
durations = durations_from_log_ieeg(log)
if ratios == 3:
    durations = [d for d in durations if ~np.isnan(d)]
    log = log[:-11]

new_events = create_events(events, durations, raw.info['sfreq'])
raw.add_events(new_events)
events_updated = mne.find_events(raw, shortest_event=1)
events_updated = check_events(events_updated)
events_updated, log = add_event_condition(events_updated, log)
events_tr_id = add_event_tr_id(events_updated)

# Epoch
t_min = -0.7
t_max = 0.7
Ejemplo n.º 3
0
def run_prepro(subj):
    ses_x_subj = sessions[subj]
    for ses in ses_x_subj:
        archivo = 'etg_su{}_se{}'.format(subj, ses)
        full_path = op.join(data_path, archivo + '.bdf')
        if not op.isfile(full_path):
            print('The session {} of subject {} is missing'.format(ses, subj))
            continue
        print('Processing Subject {} - Session {}'.format(subj, ses))

        raw = mne.io.read_raw_edf(full_path, preload=True)
        # raw.plot(n_channels=32, duration=2)
        montage = mne.channels.read_montage('biosemi128')
        head_channs = montage.ch_names[:128]
        head_channs.append('STI 014')

        raw.pick_channels(ch_names=head_channs)
        raw.set_montage(montage)

        bads = bad_channs[subj]
        raw.info['bads'] = bads

        picks_eeg = mne.pick_types(raw.info,
                                   eeg=True,
                                   meg=False,
                                   eog=False,
                                   exclude='bads')

        raw, ref = mne.io.set_eeg_reference(raw, ref_channels=None)

        raw.apply_proj()

        raw.filter(l_freq=0.1,
                   h_freq=40,
                   filter_length='auto',
                   l_trans_bandwidth='auto',
                   h_trans_bandwidth='auto')
        raw.plot(n_channels=32, duration=5)

        # ICA
        reject = {'eeg': 120e-6}
        n_components = 20
        method = 'infomax'
        decim = 4
        ica = mne.preprocessing.ICA(n_components=n_components, method=method)
        ica.fit(raw, picks=picks_eeg, decim=decim, reject=reject)
        print(ica)
        ica.plot_components()
        comp_to_delete = [
            int(x)
            for x in input('Components to delete (ej: 1 2 3): ').split()
        ]
        if comp_to_delete:
            ica.exclude = comp_to_delete
            raw = ica.apply(raw)

        raw.interpolate_bads()

        # Log
        log_filename = op.join(log_path,
                               archivo[:4] + 'scalp_' + archivo[4:] + '.mat')

        log = read_log_file(log_filename)

        # Events
        events = mne.find_events(raw)
        events = check_events(events)
        durations = durations_from_log(log)

        new_events = create_events(events, durations, raw.info['sfreq'])
        raw.add_events(new_events)
        events_updated = mne.find_events(raw, shortest_event=1)
        events_updated = check_events(events_updated)

        # events_updated = add_event_condition(events_updated, log)
        # mne.viz.plot_events(events_updated)

        # Epoch
        t_min = -0.4
        t_max = 4
        baseline = (None, 0)

        event_id = dict(s2=2)

        # event_id = marks
        epoch = mne.Epochs(raw,
                           events_updated,
                           event_id=event_id,
                           tmin=t_min,
                           tmax=t_max,
                           baseline=baseline,
                           reject=reject,
                           preload=True)
        # epoch.plot(n_epochs=10)

        # Downsample
        epoch.resample(256, n_jobs=n_jobs)
        epoch.save(op.join(study_path, 'fif/',
                           archivo + 'avg_subcond-epo.fif'))
        print('\n' * 4)
Ejemplo n.º 4
0
def run_prepro(subj):
    ses_x_subj = sessions[subj]

    montage = mne.channels.read_montage('biosemi128')
    head_channs = montage.ch_names[:128]
    head_channs.append('STI 014')

    all_ses = list()
    all_log = list()
    for ses in ses_x_subj:
        # EEG
        file = 'etg_su{}_se{}' .format(subj, ses)
        full_path = op.join(data_path, file + '.bdf')
        if not op.isfile(full_path):
            print('The session {} of subject {} is missing' .format(ses, subj))
            continue
        print('Processing Subject {} - Session {}' .format(subj, ses))
        raw = mne.io.read_raw_edf(full_path, preload=True)

        # LOG
        log_filename = op.join(log_path, file[:4] + 'scalp_' + file[4:] + '.mat')
        log = read_log_file(log_filename)
        log['session'] = ses
        log['subject'] = subj
        all_log.append(log)

        # Events
        events = mne.find_events(raw)
        events = check_events(events)
        durations = durations_from_log(log)

        new_events = create_events(events, durations, raw.info['sfreq'])
        raw.add_events(new_events)

        raw.pick_channels(ch_names=head_channs)

        all_ses.append(raw)

    if len(all_ses) > 1:
        raw_cat = mne.concatenate_raws(all_ses, preload=True)
        logs = pd.concat(all_log, ignore_index=True)
    else:
        raw_cat = raw
        logs = log

    del all_ses
    del raw
    events = mne.find_events(raw_cat)
    events = check_events(events)
    # mne.viz.plot_events(events)

    try:
        check_events_and_log(events, logs)
    except ValueError as err:
        print(err, ' - subj:', subj)
        return

    raw_cat.set_montage(montage)

    bads = bad_channs[subj]
    raw_cat.info['bads'] = bads

    picks_eeg = mne.pick_types(raw_cat.info, eeg=True, meg=False, eog=False, exclude='bads')

    raw, ref = mne.io.set_eeg_reference(raw_cat, ref_channels=None)
    raw.apply_proj()

    raw.filter(l_freq=0.1, h_freq=40, filter_length='auto', l_trans_bandwidth='auto', h_trans_bandwidth='auto', n_jobs=n_jobs)
    #raw.plot(events, n_channels=128, duration=20, scalings={'eeg': 40e-6})

    # ICA
    reject = {'eeg': 250e-6}
    n_components = 20
    method = 'extended-infomax'
    decim = 4
    ica = mne.preprocessing.ICA(n_components=n_components, method=method)
    ica.fit(raw_cat, picks=picks_eeg, decim=decim, reject=reject)
    print(ica)
    ica.plot_components()
    comp_to_delete = [int(x) for x in input('Components to delete (ej: 1 2 3): ').split()]
    if comp_to_delete:
        ica.plot_properties(raw_cat, picks=comp_to_delete)
        comp_to_delete = [int(x) for x in input('Confirm components to delete (ej: 1 2 3): ').split()]
        if comp_to_delete:
            ica.exclude = comp_to_delete
            raw_cat = ica.apply(raw_cat)

    raw_cat.interpolate_bads()

    raw_cat.save(op.join(study_path, 'fif', 'v2', '{}_prep-raw.fif' .format(subj)), overwrite=True)
    logs.to_csv(op.join(study_path, 'logs',  '{}_prep-raw.csv' .format(subj)))
    del raw_cat
    print('\n' * 4)