Пример #1
0
def calc_labels_data(elecs_lookup, stim_data, stim_labels, hemi=None):
    labels_names = list(elecs_lookup.keys())
    labels_data = np.zeros(
        (len(labels_names), stim_data.shape[1], stim_data.shape[2]))
    colors = np.zeros((*labels_data.shape, 3))
    labels_data_names = []
    label_ind = 0
    for label_name, electordes_data in elecs_lookup.items():
        if not hemi is None:
            if lu.get_hemi_from_name(label_name) != hemi:
                continue
        labels_data_names.append(label_name)
        for elec_name, elec_prob in electordes_data:
            elec_inds = np.where(stim_labels == elec_name)[0]
            if len(elec_inds) > 0:
                elec_data = stim_data[elec_inds[0], :, :] * elec_prob
                labels_data[label_ind, :, :] += elec_data
        label_ind += 1
    # Calc colors for each freq
    for freq_id in range(labels_data.shape[2]):
        data_min, data_max = utils.check_min_max(labels_data[:, :, freq_id],
                                                 norm_percs=args.norm_percs)
        colors[:, :, freq_id] = utils.mat_to_colors(labels_data[:, :, freq_id],
                                                    data_min,
                                                    data_max,
                                                    colorsMap=args.colors_map)
    return labels_data, colors, labels_data_names
Пример #2
0
def calc_connections_colors(data, labels, hemis, args):
    # stat, conditions, w, threshold=0, threshold_percentile=0, color_map='jet',
    #                         norm_by_percentile=True, norm_percs=(1, 99), symetric_colors=True):
    M = data.shape[0]
    W = data.shape[2] if args.windows == 0 else args.windows
    L = int((M * M + M) / 2 - M)
    con_indices = np.zeros((L, 2))
    con_values = np.zeros((L, W, len(args.conditions)))
    con_names = [None] * L
    con_type = np.zeros((L))
    for cond in range(len(args.conditions)):
        for w in range(W):
            for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
                if W > 1:
                    con_values[ind, w, cond] = data[i, j, w, cond]
                elif data.ndim > 2:
                    con_values[ind, w, cond] = data[i, j, cond]
                else:
                    con_values[ind, w, cond] = data[i, j]
    if len(args.conditions) > 1:
        stat_data = utils.calc_stat_data(con_values, args.stat)
    else:
        stat_data = np.squeeze(con_values)

    for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
        con_indices[ind, :] = [i, j]
        con_names[ind] = '{}-{}'.format(labels[i], labels[j])
        con_type[ind] = HEMIS_WITHIN if hemis[i] == hemis[j] else HEMIS_BETWEEN

    con_indices = con_indices.astype(np.int)
    con_names = np.array(con_names)
    if args.threshold_percentile > 0:
        args.threshold = np.percentile(np.abs(stat_data),
                                       args.threshold_percentile)
    if args.threshold >= 0:
        indices = np.where(np.abs(stat_data) > args.threshold)[0]
        # con_colors = con_colors[indices]
        con_indices = con_indices[indices]
        con_names = con_names[indices]
        con_values = con_values[indices]
        con_type = con_type[indices]
        stat_data = stat_data[indices]

    con_values = np.squeeze(con_values)
    if args.data_max == 0 and args.data_min == 0:
        data_max, data_min = utils.get_data_max_min(stat_data,
                                                    args.norm_by_percentile,
                                                    args.norm_percs)
        if args.symetric_colors and np.sign(data_max) != np.sign(data_min):
            data_minmax = max(map(abs, [data_max, data_min]))
            data_max, data_min = data_minmax, -data_minmax
    else:
        data_max, data_min = args.data_max, args.data_min
    con_colors = utils.mat_to_colors(stat_data, data_min, data_max,
                                     args.color_map)

    print(len(con_names))
    return con_colors, con_indices, con_names, con_values, con_type, data_max, data_min
Пример #3
0
def calc_connections_colors(data, labels, hemis, args):
    # stat, conditions, w, threshold=0, threshold_percentile=0, color_map='jet',
    #                         norm_by_percentile=True, norm_percs=(1, 99), symetric_colors=True):
    M = data.shape[0]
    W = data.shape[2] if args.windows == 0 else args.windows
    L = int((M * M + M) / 2 - M)
    con_indices = np.zeros((L, 2))
    con_values = np.zeros((L, W, len(args.conditions)))
    con_names = [None] * L
    con_type = np.zeros((L))
    for cond in range(len(args.conditions)):
        for w in range(W):
            for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
                if W > 1 and data.ndim == 4:
                    con_values[ind, w, cond] = data[i, j, w, cond]
                elif data.ndim > 2:
                    con_values[ind, w, cond] = data[i, j, cond]
                else:
                    con_values[ind, w, cond] = data[i, j]
    if len(args.conditions) > 1:
        stat_data = utils.calc_stat_data(con_values, args.stat)
    else:
        stat_data = np.squeeze(con_values)

    for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
        con_indices[ind, :] = [i, j]
        con_names[ind] = '{}-{}'.format(labels[i], labels[j])
        con_type[ind] = HEMIS_WITHIN if hemis[i] == hemis[j] else HEMIS_BETWEEN

    con_indices = con_indices.astype(np.int)
    con_names = np.array(con_names)
    data_max, data_min = utils.get_data_max_min(stat_data, args.norm_by_percentile, args.norm_percs)
    data_minmax = max(map(abs, [data_max, data_min]))
    if args.threshold_percentile > 0:
        args.threshold = np.percentile(np.abs(stat_data), args.threshold_percentile)
    if args.threshold > data_minmax:
        raise Exception('threshold > abs(max(data)) ({})'.format(data_minmax))
    if args.threshold >= 0:
        indices = np.where(np.abs(stat_data) > args.threshold)[0]
        # con_colors = con_colors[indices]
        con_indices = con_indices[indices]
        con_names = con_names[indices]
        con_values = con_values[indices]
        con_type  = con_type[indices]
        stat_data = stat_data[indices]

    con_values = np.squeeze(con_values)
    if args.data_max == 0 and args.data_min == 0:
        if args.symetric_colors and np.sign(data_max) != np.sign(data_min):
            data_max, data_min = data_minmax, -data_minmax
    else:
        data_max, data_min = args.data_max, args.data_min
    print('data_max: {}, data_min: {}'.format(data_max, data_min))
    con_colors = utils.mat_to_colors(stat_data, data_min, data_max, args.color_map)

    print(len(con_names))
    return con_colors, con_indices, con_names, con_values, con_type, data_max, data_min
Пример #4
0
def load_stim_file(subject, args):
    stim_fname = op.join(
        MMVT_DIR, subject, 'electrodes',
        '{}{}.npz'.format(args.file_frefix, args.stim_channel))
    stim = np.load(stim_fname)
    labels, psd, time, freqs = (stim[k]
                                for k in ['labels', 'psd', 'time', 'freqs'])
    bipolar = '-' in labels[0]
    data = None
    freqs_dim = psd.shape.index(len(freqs))
    labels_dim = psd.shape.index(len(labels))
    if time.ndim > 0:
        time_dim = psd.shape.index(len(time))
    else:
        time_dim = next(iter(set(range(3)) - set([freqs_dim, labels_dim])))
    T, L, F = psd.shape[time_dim], psd.shape[labels_dim], psd.shape[freqs_dim]
    if args.downsample > 1:
        time = utils.downsample(time, args.downsample)
    colors = None
    conditions = []
    for freq_ind, (freq_from, freq_to) in enumerate(freqs):
        if data is None:
            # initialize the data matrix (electrodes_num x T x freqs_num)
            data = np.zeros((L, T, F))
        psd_slice = get_psd_freq_slice(psd, freq_ind, freqs_dim, time_dim)
        if args.downsample > 1:
            psd_slice = utils.downsample(psd_slice, args.downsample)
        data[:, :, freq_ind] = psd_slice
        data_min, data_max = utils.calc_min_max(psd_slice,
                                                norm_percs=args.norm_percs)
        if colors is None:
            colors = np.zeros((*data.shape, 3))
        for elec_ind, elec_name in enumerate(labels):
            elec_group = utils.elec_group(elec_name, bipolar)
            # if elec_group in ['LVF', 'RMT']:
            #     colors[elec_ind, :, freq_ind] = utils.mat_to_colors(psd_slice[elec_ind], data_min, data_max, colorsMap='BuGn')
            # else:
            colors[elec_ind, :,
                   freq_ind] = utils.mat_to_colors(psd_slice[elec_ind],
                                                   data_min,
                                                   data_max,
                                                   colorsMap=args.colors_map)
        conditions.append('{}-{}Hz'.format(freq_from, freq_to))
    output_fname = op.join(
        MMVT_DIR, subject, 'electrodes',
        'stim_electrodes_{}{}_{}.npz'.format(args.file_frefix,
                                             'bipolar' if bipolar else '',
                                             args.stim_channel))
    print('Saving {}'.format(output_fname))
    np.savez(output_fname,
             data=data,
             names=labels,
             conditions=conditions,
             colors=colors)
    return dict(data=data, labels=labels, conditions=conditions, colors=colors)
Пример #5
0
def calc_connections_colors(data,
                            labels,
                            hemis,
                            stat,
                            w,
                            threshold=0,
                            threshold_percentile=0,
                            color_map='jet',
                            norm_by_percentile=True,
                            norm_percs=(1, 99)):
    M = data.shape[0]
    W = data.shape[2] if w == 0 else w
    L = int((M * M + M) / 2 - M)
    con_indices = np.zeros((L, 2))
    con_values = np.zeros((L, W, 2))
    con_names = [None] * L
    con_type = np.zeros((L))
    axis = data.ndim - 1
    coh_stat = utils.calc_stat_data(data, stat, axis=axis)
    x = coh_stat.ravel()
    data_max, data_min = utils.get_data_max_min(x, norm_by_percentile,
                                                norm_percs)
    data_minmax = max(map(abs, [data_max, data_min]))
    for cond in range(2):
        for w in range(W):
            for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
                if W > 1:
                    con_values[ind, w, cond] = data[i, j, w, cond]
                else:
                    con_values[ind, w, cond] = data[i, j, cond]
    stat_data = utils.calc_stat_data(con_values, stat)
    con_colors = utils.mat_to_colors(stat_data, -data_minmax, data_minmax,
                                     color_map)

    for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
        con_indices[ind, :] = [i, j]
        con_names[ind] = '{}-{}'.format(labels[i], labels[j])
        con_type[ind] = HEMIS_WITHIN if hemis[i] == hemis[j] else HEMIS_BETWEEN

    con_indices = con_indices.astype(np.int)
    con_names = np.array(con_names)
    if threshold_percentile > 0:
        threshold = np.percentile(np.abs(stat_data), threshold_percentile)
    if threshold > 0:
        indices = np.where(np.abs(stat_data) >= threshold)[0]
        con_colors = con_colors[indices]
        con_indices = con_indices[indices]
        con_names = con_names[indices]
        con_values = con_values[indices]
        con_type = con_type[indices]
    print(len(con_names))
    return con_colors, con_indices, con_names, con_values, con_type
Пример #6
0
def calc_connections_colors(subject,
                            data,
                            labels,
                            hemis,
                            stat,
                            threshold=0,
                            color_map='jet',
                            norm_by_percentile=True,
                            norm_percs=(1, 99)):
    # cm_big='YlOrRd', cm_small='PuBu', flip_cm_big=True, flip_cm_small=False):
    M = data.shape[0]
    W = data.shape[2]
    L = int((M * M + M) / 2 - M)
    # con_colors = np.zeros((L, W, 3))
    con_indices = np.zeros((L, 2))
    con_values = np.zeros((L, W, 2))
    con_names = [None] * L
    con_type = np.zeros((L))
    coh_stat = utils.calc_stat_data(data, stat, axis=3)
    x = coh_stat.ravel()
    data_max, data_min = utils.get_data_max_min(x, norm_by_percentile,
                                                norm_percs)
    data_minmax = max(map(abs, [data_max, data_min]))
    # sm = utils.get_scalar_map(threshold, data_max, color_map=color_map)
    for cond in range(2):
        for w in range(W):
            # win_colors = utils.mat_to_colors(coh[:, :, w, cond], threshold, max_x, color_map, sm)
            # coh_arr = utils.lower_rec_to_arr(coh[:, :, w, cond])
            # win_colors = utils.arr_to_colors(coh_arr, threshold, max_x, color_map, sm)
            for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
                # con_colors[ind, w, cond, :] = win_colors[ind][:3]
                con_values[ind, w, cond] = data[i, j, w, cond]
    stat_data = utils.calc_stat_data(con_values, stat)
    con_colors = utils.mat_to_colors(stat_data, -data_minmax, data_minmax,
                                     color_map)

    for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
        con_indices[ind, :] = [i, j]
        con_names[ind] = '{}-{}'.format(labels[i].astype(str),
                                        labels[j].astype(str))
        con_type[ind] = HEMIS_WITHIN if hemis[i] == hemis[j] else HEMIS_BETWEEN

    print(L, ind)
    con_indices = con_indices.astype(np.int)
    return con_colors, con_indices, con_names, con_values, con_type
Пример #7
0
def create_coloring(x, subject, atlas, conditions, colors_map='YlOrRd', exclude=['unknown', 'corpuscallosum'],
                    colors_min_val=None, colors_max_val=None):
    labels = lu.read_labels(subject, SUBJECTS_DIR, atlas, exclude=tuple(exclude), sorted_according_to_annot_file=True,
                            only_names=True)
    for cond_id, cond_name in enumerate(conditions):
        values = x[:, cond_id]
        if colors_min_val is None:
            colors_min_val = np.min(x)
        if colors_max_val is None:
            colors_max_val = np.max(x)
        colors = utils.arr_to_colors(values, colors_min_val, colors_max_val, colors_map=colors_map)
        coloring_fname = op.join(MMVT_DIR, subject, 'coloring', 'labels_{}_coloring.csv'.format(cond_name))
        write_coloring_file(coloring_fname, labels, colors)
    values_diff = np.squeeze(np.diff(x))
    abs_max = max(map(abs, [np.max(values_diff), np.min(values_diff)]))
    colors = utils.mat_to_colors(values_diff, -abs_max, abs_max, 'RdBu', flip_cm=True)
    coloring_fname = op.join(MMVT_DIR, subject, 'coloring', 'labels_{}_{}_diff_coloring.csv'.format(*conditions))
    write_coloring_file(coloring_fname, labels, colors)
Пример #8
0
def create_coloring(x, subject, atlas, conditions, colors_map='YlOrRd', exclude=['unknown', 'corpuscallosum'],
                    colors_min_val=None, colors_max_val=None):
    labels = lu.read_labels(subject, SUBJECTS_DIR, atlas, exclude=exclude, sorted_according_to_annot_file=True,
                            only_names=True)
    for cond_id, cond_name in enumerate(conditions):
        values = x[:, cond_id]
        if colors_min_val is None:
            colors_min_val = np.min(x)
        if colors_max_val is None:
            colors_max_val = np.max(x)
        colors = utils.arr_to_colors(values, colors_min_val, colors_max_val, colors_map=colors_map)
        coloring_fname = op.join(MMVT_DIR, subject, 'coloring', 'labels_{}_coloring.csv'.format(cond_name))
        write_coloring_file(coloring_fname, labels, colors)
    values_diff = np.squeeze(np.diff(x))
    abs_max = max(map(abs, [np.max(values_diff), np.min(values_diff)]))
    colors = utils.mat_to_colors(values_diff, -abs_max, abs_max, 'RdBu', flip_cm=True)
    coloring_fname = op.join(MMVT_DIR, subject, 'coloring', 'labels_{}_{}_diff_coloring.csv'.format(*conditions))
    write_coloring_file(coloring_fname, labels, colors)
Пример #9
0
def read_electrodes_data(elecs_data_dic, conditions, montage_file, output_file_name, from_t=0, to_t=None,
                         norm_by_percentile=True, norm_percs=(1,99)):
    for cond_id, (field, file_name) in enumerate(elecs_data_dic.iteritems()):
        d = sio.loadmat(file_name)
        if cond_id == 0:
            data = np.zeros((d[field].shape[0], to_t - from_t, 2))
        times = np.arange(0, to_t*2, 2)
        # todo: Need to do some interpulation for the MEG
        data[:, :, cond_id] = d[field][:, times]
        # time = d['Time']
    if norm_by_percentile:
        norm_val = max(map(abs, [np.percentile(data, norm_percs[ind]) for ind in [0,1]]))
    else:
        norm_val = max(map(abs, [np.max(data), np.min(data)]))
    data /= norm_val
    sfp = mne.channels.read_montage(montage_file)
    avg_data = np.mean(data, 2)
    colors = utils.mat_to_colors(avg_data, np.percentile(avg_data, 10), np.percentile(avg_data, 90), colorsMap='RdBu', flip_cm=True)
    np.savez(output_file_name, data=data, names=sfp.ch_names, conditions=conditions, colors=colors)
Пример #10
0
def calc_connections_colors(data, labels, hemis, stat, w, threshold=0, threshold_percentile=0, color_map='jet',
                            norm_by_percentile=True, norm_percs=(1, 99)):
    M = data.shape[0]
    W = data.shape[2] if w == 0 else w
    L = int((M * M + M) / 2 - M)
    con_indices = np.zeros((L, 2))
    con_values = np.zeros((L, W, 2))
    con_names = [None] * L
    con_type = np.zeros((L))
    axis = data.ndim - 1
    coh_stat = utils.calc_stat_data(data, stat, axis=axis)
    x = coh_stat.ravel()
    data_max, data_min = utils.get_data_max_min(x, norm_by_percentile, norm_percs)
    data_minmax = max(map(abs, [data_max, data_min]))
    for cond in range(2):
        for w in range(W):
            for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
                if W > 1:
                    con_values[ind, w, cond] = data[i, j, w, cond]
                else:
                    con_values[ind, w, cond] = data[i, j, cond]
    stat_data = utils.calc_stat_data(con_values, stat)
    con_colors = utils.mat_to_colors(stat_data, -data_minmax, data_minmax, color_map)

    for ind, (i, j) in enumerate(utils.lower_rec_indices(M)):
        con_indices[ind, :] = [i, j]
        con_names[ind] = '{}-{}'.format(labels[i], labels[j])
        con_type[ind] = HEMIS_WITHIN if hemis[i] == hemis[j] else HEMIS_BETWEEN

    con_indices = con_indices.astype(np.int)
    con_names = np.array(con_names)
    if threshold_percentile > 0:
        threshold = np.percentile(np.abs(stat_data), threshold_percentile)
    if threshold > 0:
        indices = np.where(np.abs(stat_data) >= threshold)[0]
        con_colors = con_colors[indices]
        con_indices = con_indices[indices]
        con_names = con_names[indices]
        con_values = con_values[indices]
        con_type  = con_type[indices]
    print(len(con_names))
    return con_colors, con_indices, con_names, con_values, con_type
Пример #11
0
def load_stim_file(subject, args):
    stim_fname = op.join(MMVT_DIR, subject, 'electrodes', '{}{}.npz'.format(
        args.file_frefix, args.stim_channel))
    stim = np.load(stim_fname)
    labels, psd, time, freqs = (stim[k] for k in ['labels', 'psd', 'time', 'freqs'])
    bipolar = '-' in labels[0]
    data = None
    freqs_dim = psd.shape.index(len(freqs))
    labels_dim = psd.shape.index(len(labels))
    if time.ndim > 0:
        time_dim = psd.shape.index(len(time))
    else:
        time_dim = next(iter(set(range(3)) - set([freqs_dim, labels_dim])))
    T, L, F = psd.shape[time_dim], psd.shape[labels_dim], psd.shape[freqs_dim]
    if args.downsample > 1:
        time = utils.downsample(time, args.downsample)
    colors = None
    conditions = []
    for freq_ind, (freq_from, freq_to) in enumerate(freqs):
        if data is None:
            # initialize the data matrix (electrodes_num x T x freqs_num)
            data = np.zeros((L, T, F))
        psd_slice = get_psd_freq_slice(psd, freq_ind, freqs_dim, time_dim)
        if args.downsample > 1:
            psd_slice = utils.downsample(psd_slice, args.downsample)
        data[:, :, freq_ind] = psd_slice
        data_min, data_max = utils.calc_min_max(psd_slice, norm_percs=args.norm_percs)
        if colors is None:
            colors = np.zeros((*data.shape, 3))
        for elec_ind, elec_name in enumerate(labels):
            elec_group = utils.elec_group(elec_name, bipolar)
            # if elec_group in ['LVF', 'RMT']:
            #     colors[elec_ind, :, freq_ind] = utils.mat_to_colors(psd_slice[elec_ind], data_min, data_max, colorsMap='BuGn')
            # else:
            colors[elec_ind, :, freq_ind] = utils.mat_to_colors(psd_slice[elec_ind], data_min, data_max, colorsMap=args.colors_map)
        conditions.append('{}-{}Hz'.format(freq_from, freq_to))
    output_fname = op.join(MMVT_DIR, subject, 'electrodes', 'stim_electrodes_{}{}_{}.npz'.format(
            args.file_frefix, 'bipolar' if bipolar else '', args.stim_channel))
    print('Saving {}'.format(output_fname))
    np.savez(output_fname, data=data, names=labels, conditions=conditions, colors=colors)
    return dict(data=data, labels=labels, conditions=conditions, colors=colors)
Пример #12
0
def calc_labels_data(elecs_lookup, stim_data, stim_labels, hemi=None):
    labels_names = list(elecs_lookup.keys())
    labels_data = np.zeros((len(labels_names), stim_data.shape[1], stim_data.shape[2]))
    colors = np.zeros((*labels_data.shape, 3))
    labels_data_names = []
    label_ind = 0
    for label_name, electordes_data in elecs_lookup.items():
        if not hemi is None:
            if lu.get_hemi_from_name(label_name) != hemi:
                continue
        labels_data_names.append(label_name)
        for elec_name, elec_prob in electordes_data:
            elec_inds = np.where(stim_labels == elec_name)[0]
            if len(elec_inds) > 0:
                elec_data = stim_data[elec_inds[0], :, :] * elec_prob
                labels_data[label_ind, :, :] += elec_data
        label_ind += 1
    # Calc colors for each freq
    for freq_id in range(labels_data.shape[2]):
        data_min, data_max = utils.calc_min_max(labels_data[:, :, freq_id], norm_percs=args.norm_percs)
        colors[:, :, freq_id] = utils.mat_to_colors(
            labels_data[:, :, freq_id], data_min, data_max, colorsMap=args.colors_map)
    return labels_data, colors, labels_data_names