def prepare_data():
from os.path import join as pjoin
from commontool.io.io import CiftiReader, save2nifti
hemi = 'lh'
brain_structure = {
'lh': 'CIFTI_STRUCTURE_CORTEX_LEFT',
'rh': 'CIFTI_STRUCTURE_CORTEX_RIGHT'
}
proj_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_pattern'
data_dir = pjoin(proj_dir, 'data/HCP')
trg_dir = pjoin(proj_dir, f'analysis/s2_rh')
trg_file = pjoin(trg_dir, f'curvature_{hemi}.nii.gz')
subj_id_file = pjoin(trg_dir, 'subject_id')
subj_id_all_file = pjoin(data_dir, 'structure/subject_id_curv')
data_file = pjoin(
data_dir, 'structure/S1200.All.curvature_MSMAll.32k_fs_LR.dscalar.nii')
subj_ids = open(subj_id_file).read().splitlines()
subj_ids_all = open(subj_id_all_file).read().splitlines()
data = CiftiReader(data_file).get_data(brain_structure[hemi], True)
indices = []
for i in subj_ids:
indices.append(subj_ids_all.index(i))
data_new = data[indices]
data_new = data_new.T[:, None, None, :]
save2nifti(trg_file, data_new)
def rois_stats():
import numpy as np
import nibabel as nib
import pickle as pkl
from os.path import join as pjoin
from commontool.io.io import save2nifti
roi_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_pattern/analysis/s2_rh/zscore/HAC_ward_euclidean/100clusters/activation/ROIs/v3'
roi_file = pjoin(roi_dir, 'rois.nii.gz')
roi2label_file = pjoin(roi_dir, 'roi2label.csv')
group_label_file = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_pattern/' \
'analysis/s2_rh/zscore/HAC_ward_euclidean/100clusters/group_labels'
rois = nib.load(roi_file).get_data().squeeze().T
group_labels_all = np.array(open(group_label_file).read().split(' '),
dtype=np.int)
roi2label = dict()
for line in open(roi2label_file).read().splitlines():
k, v = line.split(',')
roi2label[k] = int(v)
# prepare rois information dict
rois_info = dict()
for roi in roi2label.keys():
rois_info[roi] = dict()
prob_maps = []
for roi, label in roi2label.items():
# get indices of groups which contain the roi
indices = rois == label
group_indices = np.any(indices, 1)
# calculate the number of the valid groups
n_group = np.sum(group_indices)
rois_info[roi]['n_group'] = n_group
# calculate the number of the subjects
n_subj = 0
group_labels = np.where(group_indices)[0] + 1
for i in group_labels:
n_subj += np.sum(group_labels_all == i)
rois_info[roi]['n_subject'] = n_subj
# calculate roi sizes for each valid group
sizes = np.sum(indices[group_indices], 1)
rois_info[roi]['sizes'] = sizes
# calculate roi probability map among valid groups
prob_map = np.mean(indices[group_indices], 0)
prob_maps.append(prob_map)
prob_maps = np.array(prob_maps).T[:, None, None, :]
# save out
pkl.dump(rois_info, open(pjoin(roi_dir, 'rois_info.pkl'), 'wb'))
save2nifti(pjoin(roi_dir, 'prob_maps.nii.gz'), prob_maps)
def calc_mean_map(connect_files, items):
connect_dir = os.path.dirname(connect_files)
mean_dir = pjoin(connect_dir, 'mean')
if not os.path.exists(mean_dir):
os.makedirs(mean_dir)
for item in items:
connect_file = connect_files.format(item=item)
data = np.atleast_2d(nib.load(connect_file).get_data())
mean = np.mean(data, 0)
out_name = os.path.basename(connect_file)
save2nifti(pjoin(mean_dir, out_name), mean)
def gen_mean_structure():
import os
import numpy as np
import nibabel as nib
from os.path import join as pjoin
from commontool.io.io import save2nifti
# predefine some variates
# -----------------------
# predefine parameters
n_clusters = [100]
hemi = 'rh'
# predefine paths
proj_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_pattern'
clustering_dir = pjoin(proj_dir, 'analysis/s2/lh')
n_cluster_dirs = pjoin(clustering_dir,
'zscore/HAC_ward_euclidean/{}clusters')
data_file = pjoin(proj_dir, 'analysis/s2/{}/curvature.nii.gz'.format(hemi))
# -----------------------
# get data
data = nib.load(data_file).get_data().squeeze().T
# analyze labels
# --------------
for n_cluster in n_clusters:
# get clustering labels of subjects
n_cluster_dir = n_cluster_dirs.format(n_cluster)
group_labels_file = pjoin(n_cluster_dir, 'group_labels')
with open(group_labels_file) as rf:
group_labels = np.array(rf.read().split(' '), dtype=np.uint16)
structure_dir = pjoin(n_cluster_dir, 'structure')
if not os.path.exists(structure_dir):
os.makedirs(structure_dir)
mean_data = np.zeros((0, data.shape[1]))
for label in np.unique(group_labels):
# get subgroup data
subgroup_data = np.atleast_2d(data[group_labels == label])
subgroup_data_mean = np.mean(subgroup_data, 0)
mean_data = np.r_[mean_data, np.atleast_2d(subgroup_data_mean)]
# output
save2nifti(pjoin(structure_dir, f'mean_curv_{hemi}.nii.gz'),
mean_data.T[:, None, None, :])
print('{}clusters: done'.format(n_cluster))
def save_mean_maps():
import os
import numpy as np
from os.path import join as pjoin
from commontool.io.io import CiftiReader, save2nifti
# predefine parameters
cluster_nums = [2]
hemi = 'lh'
structure_name = 'curv'
project_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_clustering'
src_file = pjoin(
project_dir,
'data/HCP_1080/S1200_1080_curvature_MSMAll_32k_fs_LR.dscalar.nii')
cluster_num_dirs = pjoin(project_dir,
's2_25_zscore/HAC_ward_euclidean/{}clusters')
brain_structure = hemi2structure[hemi]
# prepare data
reader = CiftiReader(src_file)
maps = reader.get_data(brain_structure, True)
for cluster_num in cluster_nums:
# get clustering labels of subjects
cluster_num_dir = cluster_num_dirs.format(cluster_num)
group_labels_path = pjoin(cluster_num_dir, 'group_labels')
with open(group_labels_path) as rf:
group_labels = np.array(rf.read().split(' '), dtype=np.uint16)
mean_maps = np.zeros((0, maps.shape[1]))
for label in sorted(set(group_labels)):
subgroup_maps = maps[group_labels == label]
subgroup_maps_mean = np.atleast_2d(np.mean(subgroup_maps, 0))
mean_maps = np.r_[mean_maps, subgroup_maps_mean]
# output
out_dir = pjoin(cluster_num_dir, 'structure')
if not os.path.exists(out_dir):
os.makedirs(out_dir)
save2nifti(
pjoin(out_dir,
'{}_{}_mean_maps.nii.gz'.format(hemi, structure_name)),
mean_maps)
print('{}_{}clusters: done'.format(structure_name, cluster_num))
def get_mpm(hid=1, hemi='lh'):
"""maximal probability map"""
import numpy as np
import nibabel as nib
from cxy_hcp_ffa.lib.predefine import roi2label
from magicbox.io.io import save2nifti
# inputs
thr = 0.25
map_indices = [1, 2]
idx2roi = {
0: 'IOG-face',
1: 'pFus-face',
2: 'mFus-face'}
prob_file = pjoin(split_dir, f'prob_maps_half{hid}_{hemi}.nii.gz')
# outputs
out_file = pjoin(split_dir, f'MPM_half{hid}_{hemi}_FFA.nii.gz')
# prepare
prob_maps = nib.load(prob_file).get_fdata()[..., map_indices]
mpm_map = np.zeros(prob_maps.shape[:3])
# calculate
supra_thr_idx_arr = prob_maps > thr
valid_idx_arr = np.any(supra_thr_idx_arr, 3)
valid_arr = prob_maps[valid_idx_arr, :]
mpm_tmp = np.argmax(valid_arr, -1)
for i, idx in enumerate(map_indices):
roi = idx2roi[idx]
idx_arr = np.zeros_like(mpm_map, dtype=np.bool8)
idx_arr[valid_idx_arr] = mpm_tmp == i
mpm_map[idx_arr] = roi2label[roi]
# verification
valid_supra_thr_idx_arr = supra_thr_idx_arr[valid_idx_arr, :]
valid_count_vec = np.sum(valid_supra_thr_idx_arr, -1)
valid_count_vec_uniq = np.zeros_like(valid_count_vec)
for i in range(len(valid_count_vec)):
valid_supra_thr_idx_vec = valid_supra_thr_idx_arr[i]
valid_count_vec_uniq[i] = \
len(set(valid_arr[i, valid_supra_thr_idx_vec]))
assert np.all(valid_count_vec == valid_count_vec_uniq)
# save
save2nifti(out_file, mpm_map)
def get_mpm(gh_id=11, hemi='lh'):
"""maximal probability map"""
import numpy as np
import nibabel as nib
from commontool.io.io import save2nifti
thr = 0.25
prob_map_file = pjoin(split_dir, f'prob_maps_GH{gh_id}_{hemi}.nii.gz')
out_file = pjoin(split_dir, f'MPM_GH{gh_id}_{hemi}.nii.gz')
prob_maps = nib.load(prob_map_file).get_data()
supra_thr_idx_arr = prob_maps > thr
prob_maps[~supra_thr_idx_arr] = 0
mpm = np.argmax(prob_maps, 3)
mpm[np.any(prob_maps, 3)] += 1
# save
save2nifti(out_file, mpm)
def roi_stats(gh_id=11, hemi='lh'):
import numpy as np
import nibabel as nib
import pickle as pkl
from cxy_hcp_ffa.lib.predefine import roi2label
from commontool.io.io import save2nifti
gh_id_file = pjoin(split_dir, f'half_id_{hemi}.npy')
roi_file = pjoin(
proj_dir, 'analysis/s2/1080_fROI/refined_with_Kevin/'
f'rois_v3_{hemi}.nii.gz')
info_trg_file = pjoin(split_dir, f'rois_info_GH{gh_id}_{hemi}.pkl')
prob_trg_file = pjoin(split_dir, f'prob_maps_GH{gh_id}_{hemi}.nii.gz')
gh_id_idx_vec = np.load(gh_id_file) == gh_id
rois = nib.load(roi_file).get_data().squeeze().T[gh_id_idx_vec]
# prepare rois information dict
rois_info = dict()
for roi in roi2label.keys():
rois_info[roi] = dict()
prob_maps = []
for roi, label in roi2label.items():
# get indices of subjects which contain the roi
indices = rois == label
subj_indices = np.any(indices, 1)
# calculate the number of the valid subjects
n_subject = np.sum(subj_indices)
rois_info[roi]['n_subject'] = n_subject
# calculate roi sizes for each valid subject
sizes = np.sum(indices[subj_indices], 1)
rois_info[roi]['sizes'] = sizes
# calculate roi probability map among valid subjects
prob_map = np.mean(indices[subj_indices], 0)
prob_maps.append(prob_map)
prob_maps = np.array(prob_maps)
# save out
pkl.dump(rois_info, open(info_trg_file, 'wb'))
save2nifti(prob_trg_file, prob_maps.T[:, None, None, :])
def compare(maps1, maps2, output_nifti, output_text, mask=None, label_names=None, p_thr=1.0):
assert maps1.shape[1] == maps2.shape[1]
vtx_num = maps1.shape[1]
if mask is None:
label_ids = list(map(str, range(vtx_num)))
trg_vertices_list = [[vtx] for vtx in range(vtx_num)]
else:
assert mask.ndim == 1
assert vtx_num == mask.shape[0]
label_ids = [int(label_id) for label_id in np.unique(mask) if label_id != 0]
trg_vertices_list = [np.where(mask == i)[0] for i in label_ids]
label_ids = list(map(str, label_ids))
if label_names is None:
label_names = label_ids.copy()
else:
assert len(label_ids) == len(label_names)
label_ids.insert(0, 'label_id')
label_names.insert(0, 'label_name')
ts = ['t']
ps = ['p']
compare_map = np.zeros(vtx_num)
for trg_vertices in trg_vertices_list:
trg_data1 = np.mean(np.atleast_2d(maps1[:, trg_vertices]), 1)
trg_data2 = np.mean(np.atleast_2d(maps2[:, trg_vertices]), 1)
t, p = ttest_ind(trg_data1, trg_data2)
ts.append(str(t))
ps.append(str(p))
compare_map[trg_vertices] = t if p < p_thr else 0
if p_thr == 1:
line1 = ','.join(label_ids)
line2 = ','.join(label_names)
line3 = ','.join(ts)
line4 = ','.join(ps)
lines = '\n'.join([line1, line2, line3, line4])
open(output_text, 'w+').writelines(lines)
save2nifti(output_nifti, compare_map)
zip(edges[:, 0], edges[:, 1], edge_data))
elif w == 'unweighted':
graph.add_edges_from(edges)
else:
raise RuntimeError("invalid method: {}".format(method))
patches = get_patch_by_LV(graph)
else:
raise RuntimeError(
"the method - {} is not supported at present!".format(method))
for label, patch in enumerate(patches, 1):
rFFA_patch_maps[idx, patch] = label
patch_stat.append(str(len(patches)))
patch_stat.extend([str(len(patch)) for patch in patches])
rFFA_patch_stats.append(','.join(patch_stat))
print('{}/{}'.format(idx + 1, rmaps.shape[0]))
header = nib.Nifti2Header()
header['descrip'] = 'FreeROI label'
save2nifti(pjoin(patch_dir, 'lFFA_patch_maps.nii.gz'.format(threshold)),
lFFA_patch_maps,
header=header)
save2nifti(pjoin(patch_dir, 'rFFA_patch_maps.nii.gz'.format(threshold)),
rFFA_patch_maps,
header=header)
open(pjoin(patch_dir, 'lFFA_patch_stats'.format(threshold)),
'w+').writelines('\n'.join(lFFA_patch_stats))
open(pjoin(patch_dir, 'rFFA_patch_stats'.format(threshold)),
'w+').writelines('\n'.join(rFFA_patch_stats))
subject_ids_selected = rf.read().splitlines()
for item in items:
if item == 'activation':
maps_file = pjoin(
project_dir,
'data/HCP_face-avg/s2/S1200.1080.FACE-AVG_level2_zstat_hp200_s2_MSMAll.dscalar.nii'
)
elif item == 'curvature':
maps_file = pjoin(
project_dir,
'data/HCP_face-avg/S1200.1080.curvature_MSMAll.32k_fs_LR.dscalar.nii'
)
else:
raise RuntimeError("{} is not supported at present!".format(item))
reader = CiftiReader(maps_file)
lmaps = reader.get_data('CIFTI_STRUCTURE_CORTEX_LEFT', True)
rmaps = reader.get_data('CIFTI_STRUCTURE_CORTEX_RIGHT', True)
lmaps_selected = []
rmaps_selected = []
for subject_id in subject_ids_selected:
subject_idx = subject_ids.index(subject_id)
lmaps_selected.append(lmaps[subject_idx])
rmaps_selected.append(rmaps[subject_idx])
save2nifti(out_file.format(hemi='lh', item=item),
np.array(lmaps_selected))
save2nifti(out_file.format(hemi='rh', item=item),
np.array(rmaps_selected))
def gen_mean_activation():
import os
import numpy as np
import nibabel as nib
from os.path import join as pjoin
from commontool.io.io import save2nifti, CiftiReader
# predefine some variates
# -----------------------
# predefine parameters
prob_thr = 1.65
n_clusters = [100]
hemi = 'rh'
brain_structure = {
'lh': 'CIFTI_STRUCTURE_CORTEX_LEFT',
'rh': 'CIFTI_STRUCTURE_CORTEX_RIGHT'
}
stats_table_titles = [
'label', '#subject', 'min', 'max', 'mean', 'min_roi', 'max_roi',
'mean_roi'
]
# predefine paths
proj_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_pattern'
clustering_dir = pjoin(proj_dir, 'analysis/s2/lh')
n_cluster_dirs = pjoin(clustering_dir,
'zscore/HAC_ward_euclidean/{}clusters')
roi_file = pjoin(proj_dir,
f'data/HCP/label/MMPprob_OFA_FFA_thr1_{hemi}.label')
activ_file = pjoin(proj_dir, 'analysis/s2/activation.dscalar.nii')
pattern_file = pjoin(proj_dir,
'analysis/s2/{}/zscore/roi_patterns.npy'.format(hemi))
# -----------------------
# get data
roi = nib.freesurfer.read_label(roi_file)
# activ = nib.load(activ_file).get_data().squeeze().T
activ = CiftiReader(activ_file).get_data(brain_structure[hemi], True)
patterns = np.load(pattern_file)
# analyze labels
# --------------
for n_cluster in n_clusters:
# get clustering labels of subjects
n_cluster_dir = n_cluster_dirs.format(n_cluster)
group_labels_file = pjoin(n_cluster_dir, 'group_labels')
with open(group_labels_file) as rf:
group_labels = np.array(rf.read().split(' '), dtype=np.uint16)
activation_dir = pjoin(n_cluster_dir, 'activation')
if not os.path.exists(activation_dir):
os.makedirs(activation_dir)
stats_table_content = dict()
for title in stats_table_titles:
# initialize statistics table content
stats_table_content[title] = []
mean_activ = np.zeros((0, activ.shape[1]))
mean_std_activ = np.zeros((0, activ.shape[1]))
prob_activ = np.zeros((0, activ.shape[1]))
mean_patterns = np.zeros((0, activ.shape[1]))
mean_std_patterns = np.zeros((0, activ.shape[1]))
for label in sorted(set(group_labels)):
# get subgroup data
subgroup_activ = np.atleast_2d(activ[group_labels == label])
subgroup_activ_mean = np.mean(subgroup_activ, 0)
subgroup_activ_prob = np.mean(subgroup_activ > prob_thr, 0)
subgroup_activ_mean_std = subgroup_activ_mean / np.std(
subgroup_activ, 0)
subgroup_activ_mean_std[np.isnan(subgroup_activ_mean_std)] = 0
subgroup_roi_activ_mean = subgroup_activ_mean[roi]
mean_activ = np.r_[mean_activ, np.atleast_2d(subgroup_activ_mean)]
mean_std_activ = np.r_[mean_std_activ,
np.atleast_2d(subgroup_activ_mean_std)]
prob_activ = np.r_[prob_activ, np.atleast_2d(subgroup_activ_prob)]
stats_table_content['label'].append(str(label))
stats_table_content['#subject'].append(str(
subgroup_activ.shape[0]))
stats_table_content['min'].append(str(np.min(subgroup_activ_mean)))
stats_table_content['max'].append(str(np.max(subgroup_activ_mean)))
stats_table_content['mean'].append(
str(np.mean(subgroup_activ_mean)))
stats_table_content['min_roi'].append(
str(np.min(subgroup_roi_activ_mean)))
stats_table_content['max_roi'].append(
str(np.max(subgroup_roi_activ_mean)))
stats_table_content['mean_roi'].append(
str(np.mean(subgroup_roi_activ_mean)))
# get mean patterns
subgroup_patterns = patterns[group_labels == label]
subgroup_patterns_mean = np.mean(subgroup_patterns, 0)
subgroup_patterns_mean_std = subgroup_patterns_mean / np.std(
subgroup_patterns, 0)
subgroup_patterns_mean = subgroup_patterns_mean[None, :]
subgroup_patterns_mean_std = subgroup_patterns_mean_std[None, :]
pattern_mean_map = np.ones(
(1, activ.shape[1])) * np.min(subgroup_patterns_mean)
pattern_mean_map[:, roi] = subgroup_patterns_mean
mean_patterns = np.r_[mean_patterns, pattern_mean_map]
pattern_mean_std_map = np.ones(
(1, activ.shape[1])) * np.min(subgroup_patterns_mean_std)
pattern_mean_std_map[:, roi] = subgroup_patterns_mean_std
mean_std_patterns = np.r_[mean_std_patterns, pattern_mean_std_map]
# save2nifti(pjoin(activation_dir, f'activ_g{label}_{hemi}.nii.gz'), subgroup_activ.T[:, None, None, :])
# output activ
save2nifti(pjoin(activation_dir, f'mean_activ_{hemi}.nii.gz'),
mean_activ.T[:, None, None, :])
save2nifti(pjoin(activation_dir, f'mean_std_activ_{hemi}.nii.gz'),
mean_std_activ.T[:, None, None, :])
save2nifti(
pjoin(activation_dir, f'prob{prob_thr}_activ_{hemi}.nii.gz'),
prob_activ.T[:, None, None, :])
save2nifti(pjoin(activation_dir, f'mean_patterns_{hemi}.nii.gz'),
mean_patterns.T[:, None, None, :])
save2nifti(pjoin(activation_dir, f'mean_std_patterns_{hemi}.nii.gz'),
mean_std_patterns.T[:, None, None, :])
# output statistics
with open(pjoin(activation_dir, f'statistics_{hemi}.csv'), 'w') as f:
f.write(','.join(stats_table_titles) + '\n')
lines = []
for title in stats_table_titles:
lines.append(stats_table_content[title])
for line in zip(*lines):
f.write(','.join(line) + '\n')
print('{}clusters: done'.format(n_cluster))
project_dir = '/nfs/s2/userhome/chenxiayu/workingdir/study/FFA_clustering'
acti_file = pjoin(
project_dir,
'data/HCP_face-avg/s2/S1200.1080.FACE-AVG_level2_zstat_hp200_s2_MSMAll.dscalar.nii'
)
patch_dir = pjoin(project_dir, 'data/HCP_face-avg/s2/patches_15/crg')
patch_file = pjoin(patch_dir, 'rFFA_patch_maps_lt15.nii.gz')
max_maps_file = pjoin(patch_dir, 'rFFA_max_maps_lt15.nii.gz')
prob_max_map_file = pjoin(patch_dir, 'rFFA_prob_max_map_lt15.nii.gz')
brain_structure = 'CIFTI_STRUCTURE_CORTEX_RIGHT'
acti_maps = CiftiReader(acti_file).get_data(brain_structure, True)
patch_maps = nib.load(patch_file).get_data()
max_maps = np.zeros_like(patch_maps)
for row in range(acti_maps.shape[0]):
labels = np.unique(patch_maps[row])
for label in labels:
if label == 0:
continue
acti_map_tmp = acti_maps[row].copy()
not_label_indices = np.logical_not(patch_maps[row] == label)
acti_map_tmp[not_label_indices] = -np.inf
max_idx = np.argmax(acti_map_tmp)
max_maps[row, max_idx] = label
prob_max_map = np.mean(max_maps > 0, 0)
header = nib.Nifti2Header()
header['descrip'] = 'FreeROI label'
save2nifti(max_maps_file, max_maps, header=header)
save2nifti(prob_max_map_file, prob_max_map)
max_num_map = np.argmax(num_maps, 0) + 1
max_prob_map = np.argmax(prob_maps, 0) + 1
top_prob_ROIs = (prob_maps > prob_thr).astype(np.int8)
top_acti_ROIs = np.zeros_like(mean_maps)
for row, mean_map_FFA in enumerate(mean_maps[:, FFA_vertices]):
col_val = list(zip(FFA_vertices, mean_map_FFA))
col_val_sorted = sorted(col_val, key=lambda x: x[1], reverse=True)
col_val_top = col_val_sorted[:int(
len(FFA_vertices) * top_acti_percent)]
for col, val in col_val_top:
top_acti_ROIs[row, col] = 1
# output maps
header = nib.Nifti2Header()
header['descrip'] = 'FreeROI label'
save2nifti(pjoin(activation_dir, '{}_mean_maps.nii.gz'.format(hemi)),
mean_maps)
save2nifti(
pjoin(activation_dir,
'{}_prob_maps_z{}.nii.gz'.format(hemi, acti_thr)), prob_maps)
# save2nifti(pjoin(activation_dir, 'max_num_map_z{}.nii.gz'.format(acti_thr)), max_num_map)
# save2nifti(pjoin(activation_dir, 'max_prob_map_z{}.nii.gz'.format(acti_thr)), max_prob_map)
# save2nifti(pjoin(activation_dir, 'top_prob_ROIs_z{}_p{}.nii.gz'.format(acti_thr, prob_thr)), top_prob_ROIs)
# save2nifti(pjoin(activation_dir, '{}_top_acti_ROIs_percent{}.nii.gz'.format(hemi, int(top_acti_percent*100))),
# top_acti_ROIs, header=header)
save2nifti(
pjoin(activation_dir, '{}_pattern_mean_maps.nii.gz'.format(hemi)),
pattern_mean_maps)
# output statistics
with open(pjoin(activation_dir, '{}_statistics.csv'.format(hemi)),
'w+') as f:
acti_maps = CiftiReader(acti_maps_file).get_data('CIFTI_STRUCTURE_CORTEX_RIGHT', True)
mask = nib.load(mask_files.format(hemi[0])).get_data().ravel()
else:
raise RuntimeError("hemi error!")
ROIs = [np.where(mask == i)[0] for i in np.unique(mask) if i != 0]
intra_subgroup_dissimilarity = None
inter_subgroup_dissimilarity = None
for roi in ROIs:
patterns = get_roi_pattern(acti_maps, roi, True)
X = leave_one_out_representation(patterns, group_labels, metric)
row_num, col_num = X.shape
intra_tmp = []
inter_tmp = []
for row in range(row_num):
for col in range(col_num):
if row == col:
intra_tmp.extend(X[row, col])
else:
inter_tmp.extend(X[row, col])
if intra_subgroup_dissimilarity is None:
intra_subgroup_dissimilarity = np.zeros((len(intra_tmp), acti_maps.shape[1]))
if inter_subgroup_dissimilarity is None:
inter_subgroup_dissimilarity = np.zeros((len(intra_tmp), acti_maps.shape[1]))
intra_subgroup_dissimilarity[:, roi] = np.atleast_2d(np.array(intra_tmp)).T
inter_subgroup_dissimilarity[:, roi] = np.atleast_2d(np.array(inter_tmp)).T
repre_dir = pjoin(cluster_num_dir, 'representation')
save2nifti(pjoin(repre_dir, '{}_intra_subgroup_dissimilarity.nii.gz'.format(hemi)), intra_subgroup_dissimilarity)
save2nifti(pjoin(repre_dir, '{}_inter_subgroup_dissimilarity.nii.gz'.format(hemi)), inter_subgroup_dissimilarity)
compare_dict = CsvReader(compare_file).to_dict(1)
valid_idx_mat = np.array(compare_dict['p']) != 'nan'
if mask_file is not None:
mask_vertices = nib.freesurfer.read_label(mask_file)
mask_idx_mat = np.zeros_like(valid_idx_mat, dtype=np.bool)
mask_idx_mat[mask_vertices] = True
valid_idx_mat = np.logical_and(valid_idx_mat, mask_idx_mat)
compare_data = np.zeros((3, maps.shape[1]))
ps_uncorrected = np.array([
float(p) for idx, p in enumerate(compare_dict['p'])
if valid_idx_mat[idx]
])
reject, ps_corrected, alpha_sidak, alpha_bonf = multipletests(
ps_uncorrected, 0.05, 'fdr_bh')
ts = [
float(t) for idx, t in enumerate(compare_dict['t'])
if valid_idx_mat[idx]
]
compare_data[0, valid_idx_mat] = ts
compare_data[1, valid_idx_mat] = -ps_uncorrected
compare_data[2, valid_idx_mat] = -ps_corrected
compare_data[0, np.logical_not(valid_idx_mat)] = np.min(ts)
compare_data[1, np.logical_not(valid_idx_mat)] = np.min(-ps_uncorrected)
compare_data[2, np.logical_not(valid_idx_mat)] = np.min(-ps_corrected)
save2nifti(
pjoin(compare_dir, '{}_g1_vs_g2_posterior_masked.nii.gz'.format(hemi)),
compare_data)
# ---compare2nifti end---
def save2mean_map(src_maps, group_labels, output_name):
mean_maps = []
for label in np.unique(group_labels):
sub_maps = np.atleast_2d(src_maps[group_labels == label])
mean_maps.append(np.mean(sub_maps, 0))
save2nifti(output_name, np.array(mean_maps))
roi = nib.freesurfer.read_label(roi_file)
activ_roi = activ[:, roi]
corrs = 1 - cdist(activ_roi, activ_roi, 'correlation')
top_corrs_stats = {'mean': [], 'min': [], 'max': []}
top_activ_means = []
for row in corrs:
top_indices = np.argsort(-row)[:n_top]
top_corrs = row[top_indices]
top_corrs_stats['mean'].append(str(np.mean(top_corrs)))
top_corrs_stats['min'].append(str(np.min(top_corrs)))
top_corrs_stats['max'].append(str(np.max(top_corrs)))
top_activ_means.append(np.mean(activ[top_indices], 0))
top_corrs_stats_file = pjoin(trg_dir, f'top{n_top}_corrs_stats.csv')
with open(top_corrs_stats_file, 'w') as wf:
text = [','.join(i) for i in zip(*list(top_corrs_stats.values()))]
text.insert(0, ','.join(top_corrs_stats.keys()))
wf.write('\n'.join(text))
top_activ_means = np.array(top_activ_means).T[:, None, None, :]
top_activ_means_file = pjoin(trg_dir, f'top{n_top}_activ_means.nii.gz')
save2nifti(top_activ_means_file, top_activ_means)
top_activ_means_roi = np.ones_like(top_activ_means) * np.min(
top_activ_means[roi], 0)
top_activ_means_roi[roi] = top_activ_means[roi]
top_activ_means_roi_file = pjoin(trg_dir,
f'top{n_top}_activ_means_roi.nii.gz')
save2nifti(top_activ_means_roi_file, top_activ_means_roi)
log_list = []
connect_dict = dict()
for result in results:
value = result.get()
if isinstance(value, list):
log_list.extend(value)
elif isinstance(value, dict):
for k, v in value.items():
if connect_dict.get(k) is None:
connect_dict[k] = [v]
else:
connect_dict[k].append(v)
else:
raise RuntimeError("invalid return")
for k, v in connect_dict.items():
if 'subject' in k:
subject_out = '\n'.join(v)
open(pjoin(project_dir, 'subject{}_id'.format(k[1])),
'w+').writelines(subject_out)
else:
out_file = out_files.format(hemi2=k[0],
label2=k[1],
roi_label=k[2],
hemi1=k[3],
label1=k[4])
save2nifti(out_file, np.array(v))
log_out = '\n'.join(log_list)
open(pjoin(project_dir, 'tseries_connectivity_log'),
'w+').writelines(log_out)
subject_ids_file = pjoin(project_dir, 'data/HCP_face-avg/s2/subject_id')
with open(subject_ids_file) as rf:
subject_ids = rf.read().splitlines()
patch_maps = nib.load(patch_file).get_data()
patch_maps_filtered = np.zeros_like(patch_maps)
patch_stats = []
label_new = 0
for row in range(patch_maps.shape[0]):
labels = np.unique(patch_maps[row])
patch_stat = [subject_ids[row]]
patch_sizes = []
for label in labels:
if label == 0:
continue
vertices = np.where(patch_maps[row] == label)[0]
size = len(vertices)
if size > size_min:
label_new += 1
patch_sizes.append(str(size))
patch_maps_filtered[row, vertices] = label_new
patch_stat.append(str(label_new))
patch_stat.extend(patch_sizes)
patch_stats.append(','.join(patch_stat))
label_new = 0
header = nib.Nifti2Header()
header['descrip'] = 'FreeROI label'
save2nifti(patch_file_filtered, patch_maps_filtered, header=header)
open(stat_file, 'w+').writelines('\n'.join(patch_stats))
# 'HCP_S1200_GroupAvg_v1/S1200.{}.white_MSMAll.32k_fs_LR.surf.gii'
geo_files = None
# mask_file = pjoin(project_dir, 'data/HCP_face-avg/s2/patches_15/crg2.3/{}FFA_patch_maps_lt15.nii.gz')
mask_file = None
# -----------------------
print('Finish: predefine some variates')
if mask_file is not None:
lh_mask = nib.load(mask_file.format('l')).get_data() != 0
rh_mask = nib.load(mask_file.format('r')).get_data() != 0
else:
lh_mask = None
rh_mask = None
if geo_files is None:
lh_faces = None
rh_faces = None
else:
raise NotImplementedError
lmaps = nib.load(maps_file.format('lh')).get_data()
rmaps = nib.load(maps_file.format('rh')).get_data()
lFFA_vertices = nib.freesurfer.read_label(FFA_label_files.format('l'))
rFFA_vertices = nib.freesurfer.read_label(FFA_label_files.format('r'))
lFFA_patterns = get_roi_pattern(lmaps, lFFA_vertices, zscore, thr, bin,
size_min, lh_faces, lh_mask)
rFFA_patterns = get_roi_pattern(rmaps, rFFA_vertices, zscore, thr, bin,
size_min, rh_faces, rh_mask)
save2nifti(pjoin(analysis_dir, 'lFFA_patterns.nii.gz'), lFFA_patterns)
save2nifti(pjoin(analysis_dir, 'rFFA_patterns.nii.gz'), rFFA_patterns)
f.writelines(regroup_ids)
max_num_map = np.argmax(nums_maps, 0) + 1
max_prob_map = np.argmax(prob_maps, 0) + 1
top_prob_ROIs = (prob_maps > prob_thr).astype(np.int8)
top_acti_ROIs = np.zeros_like(mean_maps)
for row, mean_map_rFFA in enumerate(mean_maps[:, rFFA_vertices]):
col_val = list(zip(rFFA_vertices, mean_map_rFFA))
col_val_sorted = sorted(col_val, key=lambda x: x[1], reverse=True)
col_val_top = col_val_sorted[:int(
len(rFFA_vertices) * top_acti_percent)]
for col, val in col_val_top:
top_acti_ROIs[row, col] = 1
# output data
save2nifti(pjoin(result_dir, 'mean_maps.nii.gz'), mean_maps)
save2nifti(pjoin(result_dir, 'prob_maps_z{}.nii.gz'.format(acti_thr)),
prob_maps)
# save2nifti(pjoin(result_dir, 'max_num_map_z{}.nii.gz'.format(acti_thr)), max_num_map)
# save2nifti(pjoin(result_dir, 'max_prob_map_z{}.nii.gz'.format(acti_thr)), max_prob_map)
# save2nifti(pjoin(result_dir, 'top_prob_ROIs_z{}_p{}.nii.gz'.format(acti_thr, prob_thr)), top_prob_ROIs)
save2nifti(
pjoin(result_dir,
'top_acti_ROIs_percent{}.nii.gz'.format(top_acti_percent * 100)),
top_acti_ROIs)
# output statistics
with open(pjoin(result_dir, 'statistics.csv'), 'w+') as f:
f.write(','.join(stats_table_titles) + '\n')
lines = []
for title in stats_table_titles:
