def compare_connectivity(subject, atlas, n_jobs=6):
for name, fol, template in zip(['hesheng', 'linda', 'freesurfer'],
[hesheng_surf_fol, linda_surf_fol, fs_surf_fol],
[hesheng_template, linda_hemi_template, fs_surf_template]):
output_fname_template = op.join(
fmri.MMVT_DIR, subject, 'fmri', '{}_labels_data_laus125_mean_{}.npz'.format(name, '{hemi}'))
if not utils.both_hemi_files_exist(output_fname_template):
args = fmri.read_cmd_args(dict(
subject=subject, atlas=atlas, function='analyze_4d_data', fmri_file_template=template, remote_fmri_dir=fol,
labels_extract_mode='mean', overwrite_labels_data=False))
pu.run_on_subjects(args, fmri.main)
for hemi in utils.HEMIS:
os.rename(op.join(fmri.MMVT_DIR, subject, 'fmri', 'labels_data_laus125_mean_{}.npz'.format(hemi)),
output_fname_template.format(hemi=hemi))
args = con.read_cmd_args(dict(
subject=subject, atlas='laus125', function='calc_lables_connectivity',
connectivity_modality='fmri', connectivity_method='corr,cv', labels_extract_mode='mean',
windows_length=34, windows_shift=4, save_mmvt_connectivity=False, calc_subs_connectivity=False,
labels_name=name, recalc_connectivity=True, n_jobs=n_jobs))
pu.run_on_subjects(args, con.main)
conn_fol = op.join(con.MMVT_DIR, subject, 'connectivity')
coloring_fol = op.join(con.MMVT_DIR, subject, 'coloring')
os.rename(op.join(conn_fol, 'fmri_corr.npy'), op.join(conn_fol, 'fmri_corr_{}.npy'.format(name)))
os.rename(op.join(conn_fol, 'fmri_corr_cv_mean.npz'), op.join(conn_fol, 'mri_corr_cv_mean_{}.npz'.format(name)))
os.rename(op.join(conn_fol, 'fmri_corr_cv_mean_mean.npz'), op.join(conn_fol, 'fmri_corr_cv_mean_mean_{}.npz'.format(name)))
os.rename(op.join(coloring_fol, 'fmri_corr_cv_mean.csv'), op.join(coloring_fol, 'fmri_corr_cv_mean_{}.csv'.format(name)))
def calc_electrodes_con(args):
# -s mg78 -a laus250 -f save_electrodes_coh --threshold_percentile 95 -c interference,non-interference
args = con.read_cmd_args(
utils.Bag(subject=args.subject,
atlas='laus250',
function='save_electrodes_coh',
threshold_percentile=95,
conditions='interference,non-interference'))
pu.run_on_subjects(args, con.main)
def calc_seed_corr(args):
args = con.read_cmd_args(dict(
function='calc_seed_corr',
subject=args.subject, atlas=args.atlas,
identifier='freesurfer', labels_regex='precentral-rh',#''post*cingulate*rh',
seed_label_name='post_cingulate_rh', seed_label_r=5, overwrite_seed_data=True,
n_jobs=args.n_jobs
))
con.call_main(args)
def example1(subject):
# subject = 'fsaverage5c'
args = con.read_cmd_args(['-s', subject])
args.atlas = 'laus125'
args.mat_fname = '/cluster/neuromind/npeled/linda/figure_file1.mat'
args.mat_field = 'figure_file'
args.windows = 1
args.stat = con.STAT_DIFF
args.threshold_percentile = 99
args.conditions = ['task', 'rest']
con.save_rois_connectivity(subject, args)
def load_connectivity_results(args):
# from src.utils import matlab_utils as matu
# mat_file = matu.load_mat_to_bag(op.join(MMVT_DIR, args.subject[0], 'connectivity', 'corr.mat'))
# conn = mat_file.mAdjMat
# labels = matu.matlab_cell_str_to_list(mat_file.mLabels)
args = con.read_cmd_args(dict(
function='calc_rois_matlab_connectivity',
subject=args.subject, atlas=args.atlas,
mat_fname=op.join(MMVT_DIR, args.subject[0], 'connectivity', 'corr.mat'),
mat_field='mAdjMat', sorted_labels_names_field='mLabelsCort',
n_jobs=args.n_jobs
))
con.call_main(args)
def example2(subject):
# subject = 'fsaverage5c'
args = con.read_cmd_args(['-s', subject])
args.atlas = 'laus125'
args.mat_fname = '/cluster/neuromind/npeled/linda/figure_file3.mat'
args.mat_field = 'matrix_cognition_ratio_fpn_dmn'
args.windows = 1
args.threshold = 0
args.norm_by_percentile = False
args.symetric_colors = False
args.color_map = 'YlOrRd'
args.data_min = 0.15
args.data_max = 0.6
con.save_rois_connectivity(subject, args)
def calc_meg_connectivity(args):
args = connectivity.read_cmd_args(
utils.Bag(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method='pli',
windows_num=1,
# windows_length=500,
# windows_shift=100,
recalc_connectivity=True,
n_jobs=args.n_jobs))
connectivity.call_main(args)
def merge_connectivity(args):
for subject in args.mri_subject:
conn_args = connectivity.read_cmd_args(
dict(subject=subject, atlas=args.atlas, norm_by_percentile=False))
meg_con = np.abs(
np.load(
op.join(MMVT_DIR, subject, 'connectivity',
'meg_static_pli.npy')).squeeze())
fmri_con = np.abs(
np.load(
op.join(MMVT_DIR, subject, 'connectivity',
'fmri_static_corr.npy')).squeeze())
d = utils.Bag(
np.load(
op.join(MMVT_DIR, subject, 'connectivity',
'meg_static_pli.npz')))
labels_names = np.load(
op.join(MMVT_DIR, subject, 'connectivity', 'labels_names.npy'))
meg_threshold, fmri_threshold = 0.3, 0.5
# if args.top_k == 0:
# L = len(d.labels)
# args.top_k = int(np.rint(L * (L - 1) / 200))
# meg_con_sparse, meg_top_k = calc_con(meg_con, args.top_k)
# fmri_con_sparse, fmri_top_k = calc_con(fmri_con, args.top_k)
# if len(set(fmri_top_k).intersection(set(meg_top_k))):
# print('fmri and meg top k intersection!')
# con = con_fmri - con_meg
# if len(np.where(con)[0]) != args.top_k * 2:
# print('Wrong number of values in the conn matrix!'.format(len(np.where(con)[0])))
# continue
meg_hub, fmri_hub = calc_hubs(meg_con, fmri_con, labels_names,
meg_threshold, fmri_threshold)
meg_con_hubs, fmri_con_hubs, join_con_hubs = create_con_with_only_hubs(
meg_con, fmri_con, meg_hub, fmri_hub, meg_threshold,
fmri_threshold)
for con_hubs, con_name in zip(
[meg_con_hubs, fmri_con_hubs, join_con_hubs],
['meg-hubs', 'fmri-hubs', 'fmri-meg-hubs']):
output_fname = op.join(MMVT_DIR, subject, 'connectivity',
'{}.npz'.format(con_name))
con_vertices_fname = op.join(MMVT_DIR, subject, 'connectivity',
'{}_vertices.pkl'.format(con_name))
connectivity.save_connectivity(subject, con_hubs, con_name,
connectivity.ROIS_TYPE,
labels_names, d.conditions,
output_fname, conn_args,
con_vertices_fname)
print('{} was saved in {}'.format(con_name, output_fname))
def calc_electrodes_rest_connectivity(args):
args = con.read_cmd_args(utils.Bag(
subject=args.subject,
function='calc_electrodes_rest_connectivity',
connectivity_modality='electrodes',
connectivity_method='pli,cv',
windows_length=1000,
windows_shift=200,
sfreq=2000.0,
fmin=8,
fmax=13,
# max_windows_num=500,
n_jobs=args.n_jobs,
))
pu.run_on_subjects(args, con.main)
def calc_meg_connectivity(args):
args = con.read_cmd_args(
utils.Bag(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method='pli,cv',
windows_length=500,
windows_shift=100,
# sfreq=1000.0,
# fmin=10,
# fmax=100
n_jobs=args.n_jobs))
pu.run_on_subjects(args, con.main)
def calc_fmri_static_connectivity(args):
args = con.read_cmd_args(
dict(
subject=args.subject,
atlas='laus125', # 'yao17'
function='calc_lables_connectivity',
connectivity_modality='fmri',
connectivity_method='corr',
labels_extract_mode='mean',
identifier='', #'freesurfer',#'hesheng', #''linda',#
save_mmvt_connectivity=False,
calc_subs_connectivity=False,
recalc_connectivity=True,
n_jobs=args.n_jobs))
con.call_main(args)
def calc_connectivity(subject,
atlas,
connectivity_method,
files,
bands,
modality,
overwrite=False,
n_jobs=4):
conn_fol = op.join(MMVT_DIR, subject, 'connectivity')
now = time.time()
for run, fif_fname in enumerate(files):
utils.time_to_go(now, run, len(files), runs_num_to_print=1)
file_name = utils.namebase(fif_fname)
labels_data_name = 'labels_data_{}-epilepsy-{}-{}-{}_{}_mean_flip_{}.npz'.format(
subject, 'dSPM', modality, file_name, atlas, '{hemi}')
if not utils.both_hemi_files_exist(
op.join(MMVT_DIR, subject, modality, labels_data_name)):
print('labels data does not exist for {}!'.format(file_name))
for band_name, band_freqs in bands.items():
output_fname = op.join(
conn_fol,
'{}_{}_{}_{}.npy'.format(modality, file_name, band_name,
connectivity_method))
if op.isfile(output_fname) and not overwrite:
print('{} {} connectivity for {} already exist'.format(
connectivity_method, band_name, file_name))
continue
print('calc_meg_connectivity: {}'.format(band_name))
con_args = connectivity.read_cmd_args(
utils.Bag(
subject=subject,
atlas=atlas,
function='calc_lables_connectivity',
connectivity_modality=modality,
connectivity_method=connectivity_method,
labels_data_name=labels_data_name,
windows_length=500,
windows_shift=100,
identifier='{}_{}'.format(file_name, band_name),
fmin=band_freqs[0],
fmax=band_freqs[1],
sfreq=2035, # clin MEG
recalc_connectivity=False,
save_mmvt_connectivity=True,
threshold_percentile=80,
n_jobs=n_jobs))
connectivity.call_main(con_args)
def calc_electrodes_rest_connectivity_from_matlab(args):
def read_matlab_and_split_into_windows(args):
import scipy.io as sio
import math
import numpy as np
import src.mmvt_addon.mmvt_utils as mu
for subject in args.subject:
data_fname = op.join(ELECTRODES_DIR, subject,
'electrodes_data_diff_data.npy')
if not op.isfile(data_fname):
d = sio.loadmat(op.join(ELECTRODES_DIR, subject, 'data.mat'))
data_mat = d['data']
electrodes_num = data_mat.shape[1]
labels = []
for label_mat in d['labels']:
group, elc1, elc2 = mu.elec_group_number(
'{1}-{0}'.format(*label_mat.split(' ')), True)
labels.append('{0}{1}-{0}{2}'.format(group, elc2, elc1))
np.save(op.join(ELECTRODES_DIR, subject, 'electrodes.npy'),
labels)
data = data_mat.swapaxes(0, 1).reshape(electrodes_num, -1)
E, T = data.shape
windows_length = 1000
windows_shift = 200
windows_nun = math.floor((T - windows_length) / windows_shift +
1)
data_winodws = np.zeros((windows_nun, E, windows_length))
for w in range(windows_nun):
data_winodws[w] = data[:, w *
windows_shift:w * windows_shift +
windows_length]
np.save(data_fname, data_winodws)
read_matlab_and_split_into_windows(args)
args = con.read_cmd_args(
utils.Bag(subject=args.subject,
function='calc_electrodes_rest_connectivity',
connectivity_modality='electrodes',
connectivity_method='pli,cv',
windows_length=1000,
windows_shift=200,
sfreq=2000.0,
n_jobs=args.n_jobs
# fmin=10,
# fmax=100
))
pu.run_on_subjects(args, con.main)
def analyse_connectivity(subject,
connectivity_method,
graph_func,
file_name,
atlas,
n_jobs=4):
bands = dict(theta=[4, 8],
alpha=[8, 15],
beta=[15, 30],
gamma=[30, 55],
high_gamma=[65, 120])
conn_fol = op.join(MMVT_DIR, subject, 'connectivity')
output_fol = utils.make_dir(op.join(conn_fol, file_name))
for band_name, band_freqs in bands.items():
output_files = [
f.format(band_name) for f in [
'meg_{}_laus125_mi_mean_flip_mean.npy', 'meg_{}_mi.npy',
'meg_{}_mi.npz'
]
]
files_exist = all(
[op.isfile(op.join(output_fol, f)) for f in output_files])
if not files_exist:
print('calc_meg_connectivity: {}'.format(band_name))
con_args = connectivity.read_cmd_args(
utils.Bag(
subject=subject,
atlas=atlas,
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method=connectivity_method,
windows_length=500,
windows_shift=100,
identifier=band_name,
fmin=band_freqs[0],
fmax=band_freqs[1],
sfreq=2035, # clin MEG
recalc_connectivity=True,
n_jobs=n_jobs))
connectivity.call_main(con_args)
for output_file_name in output_files:
utils.move_file(op.join(conn_fol, output_file_name),
output_fol)
con_name = 'meg_{}_mi'.format(band_name)
analyze_graph(subject, file_name, con_name, graph_func, n_jobs)
plot_graph_values(subject, file_name, con_name, graph_func)
def calc_meg_gamma_connectivity(args):
args = con.read_cmd_args(utils.Bag(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method='pli',
windows_length=100,
windows_shift=10,
# sfreq=1000.0,
fmin=30,
fmax=55,
recalc_connectivity=True,
# max_windows_num=100,
n_jobs=args.n_jobs
))
con.call_main(args)
def calc_fmri_connectivity(args):
'-s hc029 -a laus125 -f calc_lables_connectivity --connectivity_modality fmri connectivity_method=corr,cv--windows_length 20 --windows_shift 3'
args = con.read_cmd_args(
dict(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='fmri',
# connectivity_method='mi_vec,cv',
connectivity_method='corr,cv',
# labels_extract_mode='pca_2,pca_4,pca_8', #mean,pca,
labels_extract_mode='mean',
windows_length=34, #20,
windows_shift=4, #3,
save_mmvt_connectivity=False,
calc_subs_connectivity=False,
recalc_connectivity=True,
n_jobs=args.n_jobs))
con.call_main(args)
def calc_meg_connectivity(args):
raw = mne.io.read_raw_fif(meg.RAW)
sfreq = raw.info['sfreq']
args = con.read_cmd_args(utils.Bag(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method='pli,cv',
windows_length=int(sfreq * 0.5), # 0.5s
windows_shift=int(sfreq * 0.1), # 0.1s,
# sfreq=1000.0,
tmin=300000,
tmax=int(300000 + sfreq * 60 * 8), # 8min, 4800 time points
# recalc_connectivity=True,
# max_windows_num=100,
# n_jobs=1,
n_jobs=args.n_jobs
))
pu.run_on_subjects(args, con.main)
def calc_meg_connectivity(args):
bands = dict(theta=[4, 8], alpha=[8, 15], beta=[15, 30], gamma=[30, 55], high_gamma=[65, 120])
for band_name, band_freqs in bands.items():
print('calc_meg_connectivity: {}'.format(band_name))
con_args = con.read_cmd_args(utils.Bag(
subject=args.subject,
atlas='laus125',
function='calc_lables_connectivity',
connectivity_modality='meg',
connectivity_method='mi',
windows_length=500,
windows_shift=100,
identifier=band_name,
fmin=band_freqs[0],
fmax=band_freqs[1],
sfreq=2035, # clin MEG
# recalc_connectivity=True,
# max_windows_num=100,
recalc_connectivity=True,
n_jobs=args.n_jobs
))
con.call_main(con_args)
def analyze_rest_fmri(args):
for subject in args.mri_subject:
remote_rest_fol = get_fMRI_rest_fol(subject, args.remote_fmri_dir)
local_rest_fname = convert_rest_dicoms_to_mgz(subject, remote_rest_fol)
if not op.isfile(local_rest_fname):
print('{}: Can\'t find {}!'.format(subject, local_rest_fname))
continue
args = fmri.read_cmd_args(
dict(
subject=subject,
atlas=args.atlas,
remote_subject_dir=args.remote_subject_dir,
function='clean_4d_data',
fmri_file_template=local_rest_fname,
))
fmri.call_main(args)
args = fmri.read_cmd_args(
dict(subject=args.subject,
atlas=args.atlas,
function='analyze_4d_data',
fmri_file_template='rest.sm6.{subject}.{hemi}.mgz',
labels_extract_mode='mean',
overwrite_labels_data=False))
fmri.call_main(args)
args = connectivity.read_cmd_args(
dict(subject=args.subject,
atlas=args.atlas,
function='calc_lables_connectivity',
connectivity_modality='fmri',
connectivity_method='corr',
labels_extract_mode='mean',
identifier='',
save_mmvt_connectivity=True,
calc_subs_connectivity=False,
recalc_connectivity=True,
n_jobs=args.n_jobs))
connectivity.call_main(args)
def analyze_rest_fmri(gargs):
good_subjects = []
for subject in gargs.mri_subject:
# remote_rest_fol = get_fMRI_rest_fol(subject, gargs.remote_fmri_dir)
# print('{}: {}'.format(subject, remote_rest_fol))
# if remote_rest_fol == '':
# continue
# local_rest_fname = convert_rest_dicoms_to_mgz(subject, remote_rest_fol, overwrite=True)
# if local_rest_fname == '':
# continue
# if not op.isfile(local_rest_fname):
# print('{}: Can\'t find {}!'.format(subject, local_rest_fname))
# continue
# args = fmri.read_cmd_args(dict(
# subject=subject,
# atlas=gargs.atlas,
# remote_subject_dir=gargs.remote_subject_dir,
# function='clean_4d_data',
# fmri_file_template=local_rest_fname,
# overwrite_4d_preproc=True
# ))
# flags = fmri.call_main(args)
# if subject not in flags or not flags[subject]['clean_4d_data']:
# continue
output_fname = op.join(MMVT_DIR, subject, 'connectivity',
'fmri_corr.npz')
if op.isfile(output_fname):
print('{} already exist!'.format(output_fname))
good_subjects.append(subject)
continue
remote_fname = op.join(
gargs.remote_fmri_rest_dir, subject, 'rest_001', '001',
'fmcpr.siemens.sm6.{}.{}.nii.gz'.format(subject, '{hemi}'))
if not utils.both_hemi_files_exist(remote_fname):
print('Couldn\t find fMRI rest data for {} ({})'.format(
subject, remote_fname))
continue
local_fmri_fol = utils.make_dir(op.join(FMRI_DIR, subject))
local_fmri_template = op.join(local_fmri_fol,
utils.namebase_with_ext(remote_fname))
if utils.both_hemi_files_exist(local_fmri_template):
print('{} al')
for hemi in utils.HEMIS:
local_fmri_fname = op.join(local_fmri_fol,
local_fmri_template.format(hemi=hemi))
if op.isfile(local_fmri_fname):
os.remove(local_fmri_fname)
utils.make_link(remote_fname.format(hemi=hemi), local_fmri_fname)
args = fmri.read_cmd_args(
dict(subject=subject,
atlas=gargs.atlas,
function='analyze_4d_data',
fmri_file_template=local_fmri_template,
labels_extract_mode='mean',
overwrite_labels_data=True))
flags = fmri.call_main(args)
if subject not in flags or not flags[subject]['analyze_4d_data']:
continue
args = connectivity.read_cmd_args(
dict(
subject=subject,
atlas=gargs.atlas,
function='calc_lables_connectivity',
connectivity_modality='fmri',
connectivity_method='corr',
labels_extract_mode='mean',
windows_length=34, # tr = 3 -> 100s
windows_shift=4, # 12s
save_mmvt_connectivity=True,
calc_subs_connectivity=False,
recalc_connectivity=True,
n_jobs=gargs.n_jobs))
flags = connectivity.call_main(args)
if subject in flags and flags[subject]['calc_lables_connectivity']:
good_subjects.append(subject)
print('{}/{} good subjects'.format(len(good_subjects),
len(gargs.mri_subject)))
print('Good subject: ', good_subjects)
print('Bad subjects: ', set(gargs.mri_subject) - set(good_subjects))
def merge_modalities_connectivity(args):
inv_method, em = 'dSPM', 'mean_flip'
meg_con_method, meg_con_mode = 'pli2_unbiased', 'multitaper'
fmri_con_method = 'corr'
conditions = ['interference', 'neutral']
threshold_perc = 90
template_con = utils.make_dir(
op.join(MMVT_DIR, args.template_brain, 'connectivity'))
# meg_con_fname = op.join(template_con, 'rest_{}_{}_{}.npz'.format(em, meg_con_method, meg_con_mode))
meg_con_fname = op.join(
template_con,
'meg_rest_{}_{}_{}_high_gamma_mean.npz'.format(em, meg_con_method,
meg_con_mode))
input_fmri_fname = op.join(template_con,
'rest_{}.npz'.format(fmri_con_method))
conn_args = connectivity.read_cmd_args(
dict(subject=args.template_brain,
atlas=args.atlas,
norm_by_percentile=False))
meg_con_dict = utils.Bag(np.load(meg_con_fname))
# meg_con = meg_con_dict.con[:, :, 4].squeeze()
meg_con = meg_con_dict.con
fmri_con_dict = utils.Bag(np.load(input_fmri_fname))
fmri_con = np.abs(fmri_con_dict.con.mean(axis=2)).squeeze()
# check_hubs_intersections(meg_con_dict, fmri_con_dict, meg_con_dict.names, threshold_perc=threshold_perc)
print(np.min(meg_con), np.max(meg_con))
print(np.min(fmri_con), np.max(fmri_con))
if not all(meg_con_dict.labels == fmri_con_dict.names):
raise Exception('Not the same names!')
meg_con = sym_mat(meg_con)
fmri_con = sym_mat(fmri_con)
labels_names = meg_con_dict.labels
meg_threshold, fmri_threshold = np.percentile(
meg_con, threshold_perc), np.percentile(fmri_con, threshold_perc)
print('meg and fMRI thresholds: {}, {}'.format(meg_threshold,
fmri_threshold))
meg_con = meg_con / (np.max(meg_con) * 2) + 0.5
fmri_con = fmri_con / (np.max(fmri_con) * 2) + 0.5
meg_threshold, fmri_threshold = np.percentile(
meg_con, threshold_perc), np.percentile(fmri_con, threshold_perc)
meg_hub, fmri_hub = calc_hubs(meg_con, fmri_con, labels_names,
meg_threshold, fmri_threshold)
meg_con_hubs, fmri_con_hubs, join_con_hubs = create_con_with_only_hubs(
meg_con, fmri_con, meg_hub, fmri_hub, meg_threshold, fmri_threshold)
for con_hubs, con_name in zip([meg_con_hubs, fmri_con_hubs, join_con_hubs],
['meg-hubs', 'fmri-hubs', 'fmri-meg-hubs']):
output_fname = op.join(MMVT_DIR, args.template_brain, 'connectivity',
'{}.npz'.format(con_name))
con_vertices_fname = op.join(MMVT_DIR, args.template_brain,
'connectivity',
'{}_vertices.pkl'.format(con_name))
connectivity.save_connectivity(
args.template_brain, con_hubs, args.atlas, con_name,
connectivity.ROIS_TYPE, labels_names, conditions, output_fname,
con_vertices_fname, conn_args.windows, conn_args.stat,
conn_args.norm_by_percentile, conn_args.norm_percs,
conn_args.threshold, conn_args.threshold_percentile,
conn_args.symetric_colors)
print('{} was saved in {}'.format(con_name, output_fname))