def any2fif(filename, interactive=False, outdir=None, channel_file=None): """ Generic file format converter """ p = qc.parse_path(filename) if outdir is not None: qc.make_dirs(outdir) if p.ext == 'pcl': eve_file = '%s/%s.txt' % (p.dir, p.name.replace('raw', 'eve')) if os.path.exists(eve_file): logger.info('Adding events from %s' % eve_file) else: eve_file = None pcl2fif(filename, interactive=interactive, outdir=outdir, external_event=eve_file) elif p.ext == 'eeg': eeg2fif(filename, interactive=interactive, outdir=outdir) elif p.ext in ['edf', 'bdf']: bdf2fif(filename, interactive=interactive, outdir=outdir) elif p.ext == 'gdf': gdf2fif(filename, interactive=interactive, outdir=outdir, channel_file=channel_file) elif p.ext == 'xdf': xdf2fif(filename, interactive=interactive, outdir=outdir) else: # unknown format logger.error( 'Ignored unrecognized file extension %s. It should be [.pcl | .eeg | .gdf | .bdf]' % p.ext)
def fif_resample(fif_dir, sfreq_target): out_dir = fif_dir + '/fif_resample%d' % sfreq_target qc.make_dirs(out_dir) for f in qc.get_file_list(fif_dir): pp = qc.parse_path(f) if pp.ext != 'fif': continue logger.info('Resampling %s' % f) raw, events = pu.load_raw(f) raw.resample(sfreq_target) fif_out = '%s/%s.fif' % (out_dir, pp.name) raw.save(fif_out) logger.info('Exported to %s' % fif_out)
def fix_channel_names(fif_dir, new_channel_names): ''' Change channel names of fif files in a given directory. Input ----- @fif_dir: path to fif files @new_channel_names: list of new channel names Output ------ Modified fif files are saved in fif_dir/corrected/ Kyuhwa Lee, 2019. ''' flist = [] for f in qc.get_file_list(fif_dir): if qc.parse_path(f).ext == 'fif': flist.append(f) if len(flist) > 0: qc.make_dirs('%s/corrected' % fif_dir) for f in qc.get_file_list(fif_dir): logger.info('\nLoading %s' % f) p = qc.parse_path(f) if p.ext == 'fif': raw, eve = pu.load_raw(f) if len(raw.ch_names) != len(new_channel_names): raise RuntimeError('The number of new channels do not matach that of fif file.') raw.info['ch_names'] = new_channel_names for ch, new_ch in zip(raw.info['chs'], new_channel_names): ch['ch_name'] = new_ch out_fif = '%s/corrected/%s.fif' % (p.dir, p.name) logger.info('Exporting to %s' % out_fif) raw.save(out_fif) else: logger.warning('No fif files found in %s' % fif_dir)
def main(input_dir, channel_file=None): count = 0 for f in qc.get_file_list(input_dir, fullpath=True, recursive=True): p = qc.parse_path(f) outdir = p.dir + '/fif/' if p.ext in ['pcl', 'bdf', 'edf', 'gdf', 'eeg', 'xdf']: logger.info('Converting %s' % f) any2fif(f, interactive=True, outdir=outdir, channel_file=channel_file) count += 1 logger.info('%d files converted.' % count)
def load_raw(rawfile, spfilter=None, spchannels=None, events_ext=None, multiplier=1, verbose='ERROR'): """ Loads data from a fif-format file. You can convert non-fif files (.eeg, .bdf, .gdf, .pcl) to fif format. Parameters: rawfile: (absolute) data file path spfilter: 'car' | 'laplacian' | None spchannels: None | list (for CAR) | dict (for LAPLACIAN) 'car': channel indices used for CAR filtering. If None, use all channels except the trigger channel (index 0). 'laplacian': {channel:[neighbor1, neighbor2, ...], ...} *** Note *** Since neurodecode puts trigger channel as index 0, data channel starts from index 1. events_ext: Add externally recorded events. [ [sample_index1, 0, event_value1],... ] multiplier: Multiply all values except triggers (to convert unit). Returns: raw: mne.io.RawArray object. First channel (index 0) is always trigger channel. events: mne-compatible events numpy array object (N x [frame, 0, type]) spfilter= {None | 'car' | 'laplacian'} """ if not os.path.exists(rawfile): logger.error('File %s not found' % rawfile) raise IOError if not os.path.isfile(rawfile): logger.error('%s is not a file' % rawfile) raise IOError extension = qc.parse_path(rawfile).ext assert extension in ['fif', 'fiff'], 'only fif format is supported' raw = mne.io.Raw(rawfile, preload=True, verbose=verbose) if spfilter is not None or multiplier is not 1: preprocess(raw, spatial=spfilter, spatial_ch=spchannels, multiplier=multiplier) if events_ext is not None: events = mne.read_events(events_ext) else: tch = find_event_channel(raw) if tch is not None: events = mne.find_events(raw, stim_channel=raw.ch_names[tch], shortest_event=1, uint_cast=True, consecutive='increasing') # MNE's annoying hidden cockroach: first_samp events[:, 0] -= raw.first_samp else: events = np.array([], dtype=np.int64) return raw, events
def trigger_def(ini_file, verbose=False): class TriggerDef(object): def __init__(self, items): self.by_name = {} self.by_value = {} for key, value in items: value = int(value) setattr(self, key, value) self.by_name[key] = value self.by_value[value] = key # show all possible trigger values def check_data(self): print('Attributes of the final class') for attr in dir(self): if not callable(getattr(self, attr)) and not attr.startswith("__"): print(attr, getattr(self, attr)) if not os.path.exists(ini_file): search_path = [] path_ini = qc.parse_path(ini_file) path_self = qc.parse_path(__file__) search_path.append(ini_file + '.ini') search_path.append('%s/%s' % (path_self.dir, path_ini.name)) search_path.append('%s/%s.ini' % (path_self.dir, path_ini.name)) for ini_file in search_path: if os.path.exists(ini_file): if verbose: logger.info('Found trigger definition file %s' % ini_file) break else: raise IOError('Trigger event definition file %s not found' % ini_file) config = ConfigParser(inline_comment_prefixes=('#', ';')) config.optionxform = str config.read(ini_file) return TriggerDef(config.items('events'))
def fif2mat(data_dir): out_dir = '%s/mat_files' % data_dir qc.make_dirs(out_dir) for rawfile in qc.get_file_list(data_dir, fullpath=True): if rawfile[-4:] != '.fif': continue raw, events = pu.load_raw(rawfile) events[:, 0] += 1 # MATLAB uses 1-based indexing sfreq = raw.info['sfreq'] data = dict(signals=raw._data, events=events, sfreq=sfreq, ch_names=raw.ch_names) fname = qc.parse_path(rawfile).name matfile = '%s/%s.mat' % (out_dir, fname) scipy.io.savemat(matfile, data) logger.info('Exported to %s' % matfile) logger.info('Finished exporting.')
# reset trigger channel raw._data[0] *= 0 raw.add_events(eve, 'TRIGGER') raw.save(rawfile_out, overwrite=True) logger.info('=== After merging ===') for key in np.unique(eve[:, 2]): if key in tdef.by_value: logger.info( '%s: %d events' % (tdef.by_value[key], len(np.where(eve[:, 2] == key)[0]))) else: logger.info('%s: %d events' % (key, len(np.where(eve[:, 2] == key)[0]))) # sample code if __name__ == '__main__': fif_dir = r'D:\data\STIMO\GO004\offline\all' trigger_file = 'triggerdef_gait_chuv.ini' events = {'BOTH_GO': ['LEFT_GO', 'RIGHT_GO']} out_dir = fif_dir + '/merged' qc.make_dirs(out_dir) for rawfile_in in qc.get_file_list(fif_dir): p = qc.parse_path(rawfile_in) if p.ext != 'fif': continue rawfile_out = '%s/%s.%s' % (out_dir, p.name, p.ext) merge_events(trigger_file, events, rawfile_in, rawfile_out)
def get_tfr(cfg, recursive=False, n_jobs=1): ''' @params: tfr_type: 'multitaper' or 'morlet' recursive: if True, load raw files in sub-dirs recursively export_path: path to save plots n_jobs: number of cores to run in parallel ''' cfg = check_config(cfg) tfr_type = cfg.TFR_TYPE export_path = cfg.EXPORT_PATH t_buffer = cfg.T_BUFFER if tfr_type == 'multitaper': tfr = mne.time_frequency.tfr_multitaper elif tfr_type == 'morlet': tfr = mne.time_frequency.tfr_morlet elif tfr_type == 'butter': butter_order = 4 # TODO: parameterize tfr = lfilter elif tfr_type == 'fir': raise NotImplementedError else: raise ValueError('Wrong TFR type %s' % tfr_type) n_jobs = cfg.N_JOBS if n_jobs is None: n_jobs = mp.cpu_count() if hasattr(cfg, 'DATA_PATHS'): if export_path is None: raise ValueError( 'For multiple directories, cfg.EXPORT_PATH cannot be None') else: outpath = export_path # custom event file if hasattr(cfg, 'EVENT_FILE') and cfg.EVENT_FILE is not None: events = mne.read_events(cfg.EVENT_FILE) file_prefix = 'grandavg' # load and merge files from all directories flist = [] for ddir in cfg.DATA_PATHS: ddir = ddir.replace('\\', '/') if ddir[-1] != '/': ddir += '/' for f in qc.get_file_list(ddir, fullpath=True, recursive=recursive): if qc.parse_path(f).ext in ['fif', 'bdf', 'gdf']: flist.append(f) raw, events = pu.load_multi(flist) else: logger.info('Loading %s' % cfg.DATA_FILE) raw, events = pu.load_raw(cfg.DATA_FILE) # custom events if hasattr(cfg, 'EVENT_FILE') and cfg.EVENT_FILE is not None: events = mne.read_events(cfg.EVENT_FILE) if export_path is None: [outpath, file_prefix, _] = qc.parse_path_list(cfg.DATA_FILE) else: file_prefix = qc.parse_path(cfg.DATA_FILE).name outpath = export_path file_prefix = qc.parse_path(cfg.DATA_FILE).name # re-referencing if cfg.REREFERENCE is not None: pu.rereference(raw, cfg.REREFERENCE[1], cfg.REREFERENCE[0]) assert cfg.REREFERENCE[0] in raw.ch_names sfreq = raw.info['sfreq'] # set channels of interest picks = pu.channel_names_to_index(raw, cfg.CHANNEL_PICKS) spchannels = pu.channel_names_to_index(raw, cfg.SP_CHANNELS) if max(picks) > len(raw.info['ch_names']): msg = 'ERROR: "picks" has a channel index %d while there are only %d channels.' %\ (max(picks), len(raw.info['ch_names'])) raise RuntimeError(msg) # Apply filters raw = pu.preprocess(raw, spatial=cfg.SP_FILTER, spatial_ch=spchannels, spectral=cfg.TP_FILTER, spectral_ch=picks, notch=cfg.NOTCH_FILTER, notch_ch=picks, multiplier=cfg.MULTIPLIER, n_jobs=n_jobs) # Read epochs classes = {} for t in cfg.TRIGGERS: if t in set(events[:, -1]): if hasattr(cfg, 'tdef'): classes[cfg.tdef.by_value[t]] = t else: classes[str(t)] = t if len(classes) == 0: raise ValueError('No desired event was found from the data.') try: tmin = cfg.EPOCH[0] tmin_buffer = tmin - t_buffer raw_tmax = raw._data.shape[1] / sfreq - 0.1 if cfg.EPOCH[1] is None: if cfg.POWER_AVERAGED: raise ValueError( 'EPOCH value cannot have None for grand averaged TFR') else: if len(cfg.TRIGGERS) > 1: raise ValueError( 'If the end time of EPOCH is None, only a single event can be defined.' ) t_ref = events[np.where( events[:, 2] == list(cfg.TRIGGERS)[0])[0][0], 0] / sfreq tmax = raw_tmax - t_ref - t_buffer else: tmax = cfg.EPOCH[1] tmax_buffer = tmax + t_buffer if tmax_buffer > raw_tmax: raise ValueError( 'Epoch length with buffer (%.3f) is larger than signal length (%.3f)' % (tmax_buffer, raw_tmax)) epochs_all = mne.Epochs(raw, events, classes, tmin=tmin_buffer, tmax=tmax_buffer, proj=False, picks=picks, baseline=None, preload=True) if epochs_all.drop_log_stats() > 0: logger.error( '\n** Bad epochs found. Dropping into a Python shell.') logger.error(epochs_all.drop_log) logger.error('tmin = %.1f, tmax = %.1f, tmin_buffer = %.1f, tmax_buffer = %.1f, raw length = %.1f' % \ (tmin, tmax, tmin_buffer, tmax_buffer, raw._data.shape[1] / sfreq)) logger.error('\nType exit to continue.\n') pdb.set_trace() except: logger.critical( '\n*** (tfr_export) Unknown error occurred while epoching ***') logger.critical('tmin = %.1f, tmax = %.1f, tmin_buffer = %.1f, tmax_buffer = %.1f, raw length = %.1f' % \ (tmin, tmax, tmin_buffer, tmax_buffer, raw._data.shape[1] / sfreq)) pdb.set_trace() power = {} for evname in classes: export_dir = outpath qc.make_dirs(export_dir) logger.info('>> Processing %s' % evname) freqs = cfg.FREQ_RANGE # define frequencies of interest n_cycles = freqs / 2. # different number of cycle per frequency if cfg.POWER_AVERAGED: # grand-average TFR epochs = epochs_all[evname][:] if len(epochs) == 0: logger.WARNING('No %s epochs. Skipping.' % evname) continue if tfr_type == 'butter': b, a = butter_bandpass(cfg.FREQ_RANGE[0], cfg.FREQ_RANGE[-1], sfreq, order=butter_order) tfr_filtered = lfilter(b, a, epochs, axis=2) tfr_hilbert = hilbert(tfr_filtered) tfr_power = abs(tfr_hilbert) tfr_data = np.mean(tfr_power, axis=0) elif tfr_type == 'fir': raise NotImplementedError else: power[evname] = tfr(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=False, return_itc=False, decim=1, n_jobs=n_jobs) power[evname] = power[evname].crop(tmin=tmin, tmax=tmax) tfr_data = power[evname].data if cfg.EXPORT_MATLAB is True: # export all channels to MATLAB mout = '%s/%s-%s-%s.mat' % (export_dir, file_prefix, cfg.SP_FILTER, evname) scipy.io.savemat( mout, { 'tfr': tfr_data, 'chs': epochs.ch_names, 'events': events, 'sfreq': sfreq, 'tmin': tmin, 'tmax': tmax, 'epochs': cfg.EPOCH, 'freqs': cfg.FREQ_RANGE }) logger.info('Exported %s' % mout) if cfg.EXPORT_PNG is True: # Inspect power for each channel for ch in np.arange(len(picks)): chname = raw.ch_names[picks[ch]] title = 'Peri-event %s - Channel %s' % (evname, chname) # mode= None | 'logratio' | 'ratio' | 'zscore' | 'mean' | 'percent' fig = power[evname].plot([ch], baseline=cfg.BS_TIMES, mode=cfg.BS_MODE, show=False, colorbar=True, title=title, vmin=cfg.VMIN, vmax=cfg.VMAX, dB=False) fout = '%s/%s-%s-%s-%s.png' % ( export_dir, file_prefix, cfg.SP_FILTER, evname, chname) fig.savefig(fout) plt.close() logger.info('Exported to %s' % fout) else: # TFR per event for ep in range(len(epochs_all[evname])): epochs = epochs_all[evname][ep] if len(epochs) == 0: logger.WARNING('No %s epochs. Skipping.' % evname) continue power[evname] = tfr(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=False, return_itc=False, decim=1, n_jobs=n_jobs) power[evname] = power[evname].crop(tmin=tmin, tmax=tmax) if cfg.EXPORT_MATLAB is True: # export all channels to MATLAB mout = '%s/%s-%s-%s-ep%02d.mat' % ( export_dir, file_prefix, cfg.SP_FILTER, evname, ep + 1) scipy.io.savemat( mout, { 'tfr': power[evname].data, 'chs': power[evname].ch_names, 'events': events, 'sfreq': sfreq, 'tmin': tmin, 'tmax': tmax, 'epochs': cfg.EPOCH, 'freqs': cfg.FREQ_RANGE }) logger.info('Exported %s' % mout) if cfg.EXPORT_PNG is True: # Inspect power for each channel for ch in np.arange(len(picks)): chname = raw.ch_names[picks[ch]] title = 'Peri-event %s - Channel %s, Trial %d' % ( evname, chname, ep + 1) # mode= None | 'logratio' | 'ratio' | 'zscore' | 'mean' | 'percent' fig = power[evname].plot([ch], baseline=cfg.BS_TIMES, mode=cfg.BS_MODE, show=False, colorbar=True, title=title, vmin=cfg.VMIN, vmax=cfg.VMAX, dB=False) fout = '%s/%s-%s-%s-%s-ep%02d.png' % ( export_dir, file_prefix, cfg.SP_FILTER, evname, chname, ep + 1) fig.savefig(fout) plt.close() logger.info('Exported %s' % fout) if hasattr(cfg, 'POWER_DIFF'): export_dir = '%s/diff' % outpath qc.make_dirs(export_dir) labels = classes.keys() df = power[labels[0]] - power[labels[1]] df.data = np.log(np.abs(df.data)) # Inspect power diff for each channel for ch in np.arange(len(picks)): chname = raw.ch_names[picks[ch]] title = 'Peri-event %s-%s - Channel %s' % (labels[0], labels[1], chname) # mode= None | 'logratio' | 'ratio' | 'zscore' | 'mean' | 'percent' fig = df.plot([ch], baseline=cfg.BS_TIMES, mode=cfg.BS_MODE, show=False, colorbar=True, title=title, vmin=3.0, vmax=-3.0, dB=False) fout = '%s/%s-%s-diff-%s-%s-%s.jpg' % (export_dir, file_prefix, cfg.SP_FILTER, labels[0], labels[1], chname) logger.info('Exporting to %s' % fout) fig.savefig(fout) plt.close() logger.info('Finished !')
# console logger handler c_handler = logging.StreamHandler(stream) c_handler.setFormatter(neurodecodeFormatter()) logger.addHandler(c_handler) # minimum possible level of all handlers #logger.setLevel(logging.DEBUG) set_log_level(logger, verbosity, -1) return logger def set_log_level(logger, verbosity, handler_id=0): ''' hander ID 0 is always stdout, followed by user-defined handlers. ''' logger.handlers[handler_id].level = LOG_LEVELS[verbosity] # init scripts ROOT = qc.parse_path(os.path.realpath(__file__)).dir for d in qc.get_dir_list(ROOT): if os.path.exists('%s/__init__.py' % d): exe_package = 'import neurodecode.%s' % d.replace(ROOT + '/', '') exec(exe_package) # set loggers logging.getLogger('matplotlib').setLevel(logging.ERROR) logger = logging.getLogger('neurodecode') logger.propagate = False init_logger(logger)
def get_tfr(fif_file, cfg, tfr, n_jobs=1): raw, events = pu.load_raw(fif_file) p = qc.parse_path(fif_file) fname = p.name outpath = p.dir export_dir = '%s/plot_%s' % (outpath, fname) qc.make_dirs(export_dir) # set channels of interest picks = pu.channel_names_to_index(raw, cfg.CHANNEL_PICKS) spchannels = pu.channel_names_to_index(raw, cfg.SP_CHANNELS) if max(picks) > len(raw.info['ch_names']): msg = 'ERROR: "picks" has a channel index %d while there are only %d channels.' %\ (max(picks), len(raw.info['ch_names'])) raise RuntimeError(msg) # Apply filters raw = pu.preprocess(raw, spatial=cfg.SP_FILTER, spatial_ch=spchannels, spectral=cfg.TP_FILTER, spectral_ch=picks, notch=cfg.NOTCH_FILTER, notch_ch=picks, multiplier=cfg.MULTIPLIER, n_jobs=n_jobs) # MNE TFR functions do not support Raw instances yet, so convert to Epoch if cfg.EVENT_START is None: raw._data[0][0] = 1 events = np.array([[0, 0, 1]]) classes = None else: classes = {'START': cfg.EVENT_START} tmax = (raw._data.shape[1] - 1) / raw.info['sfreq'] epochs_all = mne.Epochs(raw, events, classes, tmin=0, tmax=tmax, picks=picks, baseline=None, preload=True) logger.info('\n>> Processing %s' % fif_file) freqs = cfg.FREQ_RANGE # define frequencies of interest n_cycles = freqs / 2. # different number of cycle per frequency power = tfr(epochs_all, freqs=freqs, n_cycles=n_cycles, use_fft=False, return_itc=False, decim=1, n_jobs=n_jobs) if cfg.EXPORT_MATLAB is True: # export all channels to MATLAB mout = '%s/%s-%s.mat' % (export_dir, fname, cfg.SP_FILTER) scipy.io.savemat( mout, { 'tfr': power.data, 'chs': power.ch_names, 'events': events, 'sfreq': raw.info['sfreq'], 'freqs': cfg.FREQ_RANGE }) if cfg.EXPORT_PNG is True: # Plot power of each channel for ch in np.arange(len(picks)): ch_name = raw.ch_names[picks[ch]] title = 'Channel %s' % (ch_name) # mode= None | 'logratio' | 'ratio' | 'zscore' | 'mean' | 'percent' fig = power.plot([ch], baseline=cfg.BS_TIMES, mode=cfg.BS_MODE, show=False, colorbar=True, title=title, vmin=cfg.VMIN, vmax=cfg.VMAX, dB=False) fout = '%s/%s-%s-%s.png' % (export_dir, fname, cfg.SP_FILTER, ch_name) fig.savefig(fout) logger.info('Exported %s' % fout) logger.info('Finished !')
def feature_importances_topo(featfile, topo_layout_file=None, channels=None, channel_name_show=None): """ Compute feature importances across frequency bands and channels @params topo_laytout_file: if not None, topography map images will be generated and saved. channel_name_show: list of channel names to show on topography map. """ logger.info('Loading %s' % featfile) if channels is None: channel_set = set() with open(featfile) as f: f.readline() for l in f: ch = l.strip().split('\t')[1] channel_set.add(ch) channels = list(channel_set) # channel index lookup table ch2index = {ch: i for i, ch in enumerate(channels)} data_delta = np.zeros(len(channels)) data_theta = np.zeros(len(channels)) data_mu = np.zeros(len(channels)) data_beta = np.zeros(len(channels)) data_beta1 = np.zeros(len(channels)) data_beta2 = np.zeros(len(channels)) data_beta3 = np.zeros(len(channels)) data_lgamma = np.zeros(len(channels)) data_hgamma = np.zeros(len(channels)) data_per_ch = np.zeros(len(channels)) f = open(featfile) f.readline() for l in f: token = l.strip().split('\t') importance = float(token[0]) ch = token[1] fq = float(token[2]) if fq <= 3: data_delta[ch2index[ch]] += importance elif fq <= 7: data_theta[ch2index[ch]] += importance elif fq <= 12: data_mu[ch2index[ch]] += importance elif fq <= 30: data_beta[ch2index[ch]] += importance elif fq <= 70: data_lgamma[ch2index[ch]] += importance else: data_hgamma[ch2index[ch]] += importance if 12.5 <= fq <= 16: data_beta1[ch2index[ch]] += importance elif fq <= 20: data_beta2[ch2index[ch]] += importance elif fq <= 28: data_beta3[ch2index[ch]] += importance data_per_ch[ch2index[ch]] += importance hlen = 18 + len(channels) * 7 result = '>> Feature importance distribution\n' result += 'bands ' + qc.list2string(channels, '%6s') + ' | ' + 'per band\n' result += '-' * hlen + '\n' result += 'delta ' + qc.list2string( data_delta, '%6.2f') + ' | %6.2f\n' % np.sum(data_delta) result += 'theta ' + qc.list2string( data_theta, '%6.2f') + ' | %6.2f\n' % np.sum(data_theta) result += 'mu ' + qc.list2string( data_mu, '%6.2f') + ' | %6.2f\n' % np.sum(data_mu) #result += 'beta ' + qc.list2string(data_beta, '%6.2f') + ' | %6.2f\n' % np.sum(data_beta) result += 'beta1 ' + qc.list2string( data_beta1, '%6.2f') + ' | %6.2f\n' % np.sum(data_beta1) result += 'beta2 ' + qc.list2string( data_beta2, '%6.2f') + ' | %6.2f\n' % np.sum(data_beta2) result += 'beta3 ' + qc.list2string( data_beta3, '%6.2f') + ' | %6.2f\n' % np.sum(data_beta3) result += 'lgamma ' + qc.list2string( data_lgamma, '%6.2f') + ' | %6.2f\n' % np.sum(data_lgamma) result += 'hgamma ' + qc.list2string( data_hgamma, '%6.2f') + ' | %6.2f\n' % np.sum(data_hgamma) result += '-' * hlen + '\n' result += 'per_ch ' + qc.list2string(data_per_ch, '%6.2f') + ' | 100.00\n' print(result) p = qc.parse_path(featfile) open('%s/%s_summary.txt' % (p.dir, p.name), 'w').write(result) # export topo maps if topo_layout_file is not None: # default visualization setting res = 64 contours = 6 # select channel names to show if channel_name_show is None: channel_name_show = channels chan_vis = [''] * len(channels) for ch in channel_name_show: chan_vis[channels.index(ch)] = ch # set channel locations and reverse lookup table chanloc = {} if not os.path.exists(topo_layout_file): topo_layout_file = NEUROD_ROOT + '/layout/' + topo_layout_file if not os.path.exists(topo_layout_file): raise FileNotFoundError('Layout file %s not found.' % topo_layout_file) logger.info('Using layout %s' % topo_layout_file) for l in open(topo_layout_file): token = l.strip().split('\t') ch = token[5] x = float(token[1]) y = float(token[2]) chanloc[ch] = [x, y] pos = np.zeros((len(channels), 2)) for i, ch in enumerate(channels): pos[i] = chanloc[ch] vmin = min(data_per_ch) vmax = max(data_per_ch) total = sum(data_per_ch) rate_delta = sum(data_delta) * 100.0 / total rate_theta = sum(data_theta) * 100.0 / total rate_mu = sum(data_mu) * 100.0 / total rate_beta = sum(data_beta) * 100.0 / total rate_beta1 = sum(data_beta1) * 100.0 / total rate_beta2 = sum(data_beta2) * 100.0 / total rate_beta3 = sum(data_beta3) * 100.0 / total rate_lgamma = sum(data_lgamma) * 100.0 / total rate_hgamma = sum(data_hgamma) * 100.0 / total export_topo(data_per_ch, pos, 'features_topo_all.png', xlabel='all bands 1-40 Hz', chan_vis=chan_vis) export_topo(data_delta, pos, 'features_topo_delta.png', xlabel='delta 1-3 Hz (%.1f%%)' % rate_delta, chan_vis=chan_vis) export_topo(data_theta, pos, 'features_topo_theta.png', xlabel='theta 4-7 Hz (%.1f%%)' % rate_theta, chan_vis=chan_vis) export_topo(data_mu, pos, 'features_topo_mu.png', xlabel='mu 8-12 Hz (%.1f%%)' % rate_mu, chan_vis=chan_vis) export_topo(data_beta, pos, 'features_topo_beta.png', xlabel='beta 13-30 Hz (%.1f%%)' % rate_beta, chan_vis=chan_vis) export_topo(data_beta1, pos, 'features_topo_beta1.png', xlabel='beta 12.5-16 Hz (%.1f%%)' % rate_beta1, chan_vis=chan_vis) export_topo(data_beta2, pos, 'features_topo_beta2.png', xlabel='beta 16-20 Hz (%.1f%%)' % rate_beta2, chan_vis=chan_vis) export_topo(data_beta3, pos, 'features_topo_beta3.png', xlabel='beta 20-28 Hz (%.1f%%)' % rate_beta3, chan_vis=chan_vis) export_topo(data_lgamma, pos, 'features_topo_lowgamma.png', xlabel='low gamma 31-40 Hz (%.1f%%)' % rate_lgamma, chan_vis=chan_vis)