def save_labels_from_vertices_lookup(subject, atlas, subjects_dir, mmvt_dir, surf_type='pial', read_labels_from_fol='', overwrite_vertices_labels_lookup=False, n_jobs=6): lookup = create_vertices_labels_lookup( subject, atlas, read_labels_from_fol=read_labels_from_fol, overwrite=overwrite_vertices_labels_lookup) labels_fol = op.join(subjects_dir, subject, 'label', atlas) surf = utils.load_surf(subject, mmvt_dir, subjects_dir) utils.delete_folder_files(labels_fol) ok = True for hemi in utils.HEMIS: labels_vertices = defaultdict(list) # surf_fname = op.join(subjects_dir, subject, 'surf', '{}.{}'.format(hemi, surf_type)) # surf, _ = mne.surface.read_surface(surf_fname) for vertice, label in lookup[hemi].items(): labels_vertices[label].append(vertice) chunks_indices = np.array_split(np.arange(len(labels_vertices)), n_jobs) labels_vertices_items = list(labels_vertices.items()) chunks = [([labels_vertices_items[ind] for ind in chunk_indices], subject, labels_vertices, surf, hemi, labels_fol) for chunk_indices in chunks_indices] results = utils.run_parallel(_save_labels_from_vertices_lookup_hemi, chunks, n_jobs) ok = ok and all(results) return ok
def subcortical_segmentation(subject, overwrite_subcortical_objs=False): # Must source freesurfer. You need to have write permissions on SUBJECTS_DIR script_fname = op.join(BRAINDER_SCRIPTS_DIR, 'aseg2srf') if not op.isfile(script_fname): raise Exception('The subcortical segmentation script is missing! {}'.format(script_fname)) if not utils.is_exe(script_fname): utils.set_exe_permissions(script_fname) # aseg2srf: For every subcortical region (8 10 11 12 13 16 17 18 26 47 49 50 51 52 53 54 58): # 1) mri_pretess: Changes region segmentation so that the neighbors of all voxels have a face in common # 2) mri_tessellate: Creates surface by tessellating # 3) mris_smooth: Smooth the new surface # 4) mris_convert: Convert the new surface into srf format function_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', 'subcortical_objs') renamed_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', 'subcortical') lookup = load_subcortical_lookup_table() obj_files = glob.glob(op.join(function_output_fol, '*.srf')) if len(obj_files) < len(lookup) or overwrite_subcortical_objs: utils.delete_folder_files(function_output_fol) # utils.delete_folder_files(aseg_to_srf_output_fol) utils.delete_folder_files(renamed_output_fol) print('Trying to write into {}'.format(function_output_fol)) utils.run_script(ASEG_TO_SRF.format(subject)) # os.rename(aseg_to_srf_output_fol, function_output_fol) ply_files = glob.glob(op.join(renamed_output_fol, '*.ply')) if len(ply_files) < len(lookup) or overwrite_subcortical_objs: convert_and_rename_subcortical_files(subject, function_output_fol, renamed_output_fol, lookup) flag_ok = len(glob.glob(op.join(renamed_output_fol, '*.ply'))) == len(lookup) and \ len(glob.glob(op.join(renamed_output_fol, '*.npz'))) == len(lookup) return flag_ok
def _calc_pvals_fMRI_clusters(p, extract_time_series_for_clusters=False): subject, overwrite = p stc_name = 'dSPM_mean_flip_vertices_power_spectrum_stat' if not utils.both_hemi_files_exist( op.join(MMVT_DIR, subject, 'meg', '{}-{}.stc'.format( stc_name, '{hemi}'))): print('{}: Can\'t find {}!'.format(subject, stc_name)) return False args.subject = subject clusters_root_fol = utils.make_dir( op.join(MMVT_DIR, subject, 'meg', 'clusters')) res_fname = op.join( clusters_root_fol, 'clusters_labels_dSPM_mean_flip_vertices_power_spectrum_stat.pkl') if not op.isfile(res_fname) or args.overwrite: utils.delete_folder_files(clusters_root_fol) _args = meg.read_cmd_args( dict(subject=subject, mri_subject=subject, atlas='MSIT_I-C', function='find_functional_rois_in_stc', stc_name=stc_name, threshold=-np.log10(0.01), threshold_is_precentile=False, extract_time_series_for_clusters=False, save_func_labels=True, calc_cluster_contours=True, n_jobs=args.n_jobs)) try: meg.call_main(_args) except: print(traceback.format_exc()) if not op.isfile(res_fname): print('Cluster output can\'t be found!') return False
def change_frames_names(fol, images_prefix, images_type, images_format_len, new_fol_name='new_images'): import shutil images = glob.glob( op.join(fol, '{}*.{}'.format(images_prefix, images_type))) images.sort(key=lambda x: int(utils.namebase(x)[len(images_prefix):])) images_formats = { 1: '{0:0>1}', 2: '{0:0>2}', 3: '{0:0>3}', 4: '{0:0>4}', 5: '{0:0>5}' } root = op.join(op.sep.join(images[0].split(op.sep)[:-1])) new_fol = op.join(root, new_fol_name) utils.delete_folder_files(new_fol) utils.make_dir(new_fol) for num, image_fname in enumerate(images): num_str = images_formats[images_format_len].format(num + 1) new_image_fname = op.join( new_fol, '{}{}.{}'.format(images_prefix, num_str, images_type)) print('{} -> {}'.format(image_fname, new_image_fname)) utils.copy_file(image_fname, new_image_fname) return new_fol
def merge_labels(subject, fmri_names): utils.delete_folder_files(op.join(MMVT_DIR, subject, 'fmri', 'labels')) vertices_labels_lookup = utils.load( op.join(MMVT_DIR, subject, 'aparc.DKTatlas40_vertices_labels_lookup.pkl')) output_fol = utils.make_dir(op.join(MMVT_DIR, subject, 'fmri', 'labels')) for fmri_name in fmri_names: labels = [] for hemi in utils.HEMIS: surf_fname = op.join( MMVT_DIR, subject, 'fmri', 'fmri_{}_{}.npy'.format( fmri_name.replace('_insulaopercula', ''), hemi)) surf_data = np.load(surf_fname) vertices_indices = np.where(surf_data >= 0.95)[0] if len(vertices_indices) == 0: continue insulaopercula_vertices = [] vertices, _ = utils.read_pial(subject, MMVT_DIR, hemi) for vert_ind in tqdm(vertices_indices): vert_label = vertices_labels_lookup[hemi][vert_ind] if vert_label.startswith( 'insula' ): # or vert_label.startswith('parsopercularis') insulaopercula_vertices.append(vert_ind) label = mne.Label(insulaopercula_vertices, vertices[insulaopercula_vertices], hemi=hemi, name=fmri_name, subject=subject) labels.append(label) label.save(op.join(output_fol, '{}.label'.format(fmri_name))) anat.labels_to_annot(subject, atlas=fmri_name, labels=labels) anat.calc_labeles_contours(subject, fmri_name)
def calc_msit_functional_rois(args): clusters_root_fol = utils.make_dir( op.join(MMVT_DIR, args.subject[0], 'meg', 'clusters')) utils.delete_folder_files(clusters_root_fol) # conditions = ['neutral', 'interference'] # for cond in conditions: _args = meg.read_cmd_args( dict( subject=args.subject, mri_subject=args.mri_subject, task='MSIT', data_per_task=True, # atlas='laus125', function='find_functional_rois_in_stc', inverse_method='dSPM', stc_name= '{subject}_msit_nTSSS_interference_interference-neutral_1-15-dSPM', inv_fname='{subject}_msit_nTSSS_interference_1-15-inv', label_name_template='*', peak_mode='pos', threshold=99.5, min_cluster_max=5, min_cluster_size=100, # recreate_src_spacing='ico5' # clusters_label='precentral' )) meg.call_main(_args)
def create_dup_frames_links(subject, dup_frames, fol): fol = op.join(MMVT_DIR, subject, 'figures', fol) utils.delete_folder_files(fol) utils.make_dir(fol) for ind, frame in enumerate(dup_frames): utils.make_link( frame, op.join(fol, 'dup_{}.{}'.format(ind, utils.file_type(frame)))) return fol
def _mri_cvs_register_parallel(p): subjects, subject_to, subjects_dir, overwrite, print_only = p for subject_from in subjects: if overwrite and not print_only: utils.delete_folder_files( op.join(subjects_dir, subject_from, 'mri_cvs_register_to_{}'.format(subject_to))) rs = utils.partial_run_script(locals(), print_only=print_only) rs(mri_cvs_register)
def rename_cortical(lookup, fol, new_fol): ply_files = glob.glob(op.join(fol, '*.ply')) utils.delete_folder_files(new_fol) for ply_file in ply_files: base_name = op.basename(ply_file) num = int(base_name.split('.')[-2]) hemi = base_name.split('.')[0] name = lookup[hemi].get(num, num) new_name = '{}-{}'.format(name, hemi) shutil.copy(ply_file, op.join(new_fol, '{}.ply'.format(new_name)))
def convert_and_rename_subcortical_files(subject, fol, new_fol, lookup, mmvt_subcorticals_fol_name='subcortical'): obj_files = glob.glob(op.join(fol, '*.srf')) utils.delete_folder_files(new_fol) for obj_file in obj_files: num = int(op.basename(obj_file)[:-4].split('_')[-1]) new_name = lookup.get(num, '') if new_name != '': utils.srf2ply(obj_file, op.join(new_fol, '{}.ply'.format(new_name))) verts, faces = utils.read_ply_file(op.join(new_fol, '{}.ply'.format(new_name))) np.savez(op.join(new_fol, '{}.npz'.format(new_name)), verts=verts, faces=faces) copy_subcorticals_to_mmvt(new_fol, subject, mmvt_subcorticals_fol_name)
def convert_and_rename_subcortical_files(subject, fol, new_fol, lookup): obj_files = glob.glob(op.join(fol, '*.srf')) utils.delete_folder_files(new_fol) for obj_file in obj_files: num = int(op.basename(obj_file)[:-4].split('_')[-1]) new_name = lookup.get(num, '') if new_name != '': utils.srf2ply(obj_file, op.join(new_fol, '{}.ply'.format(new_name))) verts, faces = utils.read_ply_file(op.join(new_fol, '{}.ply'.format(new_name))) np.savez(op.join(new_fol, '{}.npz'.format(new_name)), verts=verts, faces=faces) copy_subcorticals_to_blender(new_fol, subject)
def duplicate_frames(fol, multiplier=50, pics_type='png'): import shutil pics = get_pics(fol, pics_type) new_fol = '{}_dup'.format(fol) utils.delete_folder_files(new_fol) pic_ind = 0 shutil.copy(op.join(fol, 'data.pkl'), op.join(new_fol, 'data.pkl')) for t, pic in enumerate(pics): for _ in range(multiplier): new_pic_name = op.join(new_fol, '{}_t{}.{}'.format(pic_ind, t, pics_type)) shutil.copy(pic, new_pic_name) pic_ind += 1
def create_functional_rois(subject, contrast_name, clusters_labels_fname='', func_rois_folder=''): if clusters_labels_fname == '': clusters_labels = utils.load(op.join( BLENDER_ROOT_DIR, subject, 'fmri', 'clusters_labels_{}.npy'.format(contrast_name))) if func_rois_folder == '': func_rois_folder = op.join(SUBJECTS_DIR, subject, 'mmvt', 'fmri', 'functional_rois', '{}_labels'.format(contrast_name)) utils.delete_folder_files(func_rois_folder) for cl in clusters_labels: cl_name = 'fmri_{}_{:.2f}'.format(cl['name'], cl['max']) new_label = mne.Label(cl['vertices'], cl['coordinates'], hemi=cl['hemi'], name=cl_name, filename=None, subject=subject, verbose=None) new_label.save(op.join(func_rois_folder, cl_name))
def duplicate_frames(fol, multiplier=50, pics_type='png'): import shutil pics = get_pics(fol, pics_type) new_fol = '{}_dup'.format(fol) utils.delete_folder_files(new_fol) pic_ind = 0 utils.copy_file(op.join(fol, 'data.pkl'), op.join(new_fol, 'data.pkl')) for t, pic in enumerate(pics): for _ in range(multiplier): new_pic_name = op.join(new_fol, '{}_t{}.{}'.format(pic_ind, t, pics_type)) utils.copy_file(pic, new_pic_name) pic_ind += 1
def find_functional_rois(subject, ictal_clips, modality, seizure_times, atlas, min_cluster_size, inverse_method, overwrite=False, n_jobs=4): fwd_usingMEG, fwd_usingEEG = meg.get_fwd_flags(modality) modality_fol = op.join(MMVT_DIR, subject, meg.modality_fol(modality)) stcs_fol = op.join(modality_fol, 'ictal-{}-zvals-stcs'.format(inverse_method)) ictlas_fname = op.join( modality_fol, '{}-epilepsy-{}-{}-amplitude-zvals-ictals.pkl'.format( subject, inverse_method, modality)) # Make sure we have a morph map, and if not, create it here, and not in the parallel function mne.surface.read_morph_map(subject, subject, subjects_dir=SUBJECTS_DIR) connectivity = anat.load_connectivity(subject) if overwrite: utils.delete_folder_files( op.join(MMVT_DIR, subject, modality_fol, 'clusters')) if op.isfile(ictlas_fname): ictals = utils.load(ictlas_fname) else: params = [(subject, clip_fname, inverse_method, modality, seizure_times, stcs_fol, n_jobs) for clip_fname in ictal_clips] ictals = utils.run_parallel(_calc_ictal_and_baseline_parallel, params, n_jobs) utils.save(ictals, ictlas_fname) for stc_name, ictal_stc, mean_baseline in ictals: max_ictal = ictal_stc.data.max() if max_ictal < mean_baseline: print('max ictal ({}) < mean baseline ({})!'.format( max_ictal, mean_baseline)) continue meg.find_functional_rois_in_stc(subject, subject, atlas, utils.namebase(stc_name), mean_baseline, threshold_is_precentile=False, extract_time_series_for_clusters=False, time_index=0, min_cluster_size=min_cluster_size, min_cluster_max=mean_baseline, fwd_usingMEG=fwd_usingMEG, fwd_usingEEG=fwd_usingEEG, stc_t_smooth=ictal_stc, modality=modality, connectivity=connectivity, n_jobs=n_jobs)
def convert_and_rename_subcortical_files(subject, fol, new_fol, lookup): obj_files = glob.glob(op.join(fol, '*.srf')) utils.delete_folder_files(new_fol) for obj_file in obj_files: num = int(op.basename(obj_file)[:-4].split('_')[-1]) new_name = lookup.get(num, '') if new_name != '': utils.srf2ply(obj_file, op.join(new_fol, '{}.ply'.format(new_name))) verts, faces = utils.read_ply_file(op.join(new_fol, '{}.ply'.format(new_name))) np.savez(op.join(new_fol, '{}.npz'.format(new_name)), verts=verts, faces=faces) blender_fol = op.join(MMVT_DIR, subject, 'subcortical') if op.isdir(blender_fol): shutil.rmtree(blender_fol) shutil.copytree(new_fol, blender_fol)
def find_functional_rois( subject, ictal_clips, modality, seizure_times, atlas, min_cluster_size, inverse_method, mean_baseline, windows_length=0.1, windows_shift=0.05, overwrite=False, n_jobs=4): modality_fol = op.join(MMVT_DIR, subject, meg.modality_fol(modality)) # Make sure we have a morph map, and if not, create it here, and not in the parallel function mne.surface.read_morph_map(subject, subject, subjects_dir=SUBJECTS_DIR) connectivity = anat.load_connectivity(subject) if overwrite: utils.delete_folder_files(op.join(MMVT_DIR, subject, modality_fol, 'clusters')) windows = calc_windows(seizure_times, windows_length, windows_shift) params = [] for ictal_clip in ictal_clips: for from_t, to_t in windows: params.append((subject, modality, ictal_clip, atlas, inverse_method, mean_baseline, from_t, to_t, min_cluster_size, connectivity)) utils.run_parallel(_find_functional_rois_parallel, params, n_jobs)
def find_diff_clusters(subject, atlas='laus125', overwrite=True): clusters_name = 'CBF_scan_rescan' if overwrite: utils.delete_folder_files(op.join( MMVT_DIR, subject, 'fmri', 'clusters_labels_{}_{}'.format(clusters_name, atlas)), delete_folder=True) utils.delete_file( op.join(MMVT_DIR, subject, 'fmri', 'clusters_labels_{}_{}.pkl'.format(clusters_name, atlas))) fMRI.find_clusters(subject, 'CBF_scan_rescan', 2, 'laus125', 2, 1, create_clusters_labels=True, new_atlas_name='CBF_scan_rescan')
def _mri_cvs_register_parallel(p): subjects, subject_to, subjects_dir, overwrite, print_only = p for subject_from in subjects: # output_fname = op.join(SUBJECTS_DIR, subject_from, 'mri_cvs_register_to_colin27', 'combined_tocolin27_elreg_afteraseg-norm.tm3d') # if op.isfile(output_fname) and not overwrite: # print('Already done for {}'.format(subject_from)) # continue # else: # print('Running mri_cvs_register for {}'.format(subject_from)) if overwrite and not print_only: utils.delete_folder_files( op.join(subjects_dir, subject_from, 'mri_cvs_register_to_{}'.format(subject_to))) rs = utils.partial_run_script(locals(), print_only=print_only) if subject_to == 'fsaverage': rs(mri_cvs_register_mni) else: rs(mri_cvs_register)
def calc_contoures(subject, fmri_names, thresholds_min=2, thresholds_max=None, thresholds_dx=2, n_jobs=4): utils.delete_folder_files(op.join(MMVT_DIR, subject, 'fmri', 'clusters')) if thresholds_max is None: thresholds_max = thresholds_min for fmri_name in fmri_names: fmri.contrast_to_contours(subject, fmri_name, thresholds_min, thresholds_max, thresholds_dx, min_cluster_size=10, find_clusters_overlapped_labeles=True, atlas='aparc.DKTatlas', n_jobs=n_jobs)
def calc_functional_rois(conds, args): clusters_root_fol = op.join(MMVT_DIR, subject, 'meg', 'clusters') utils.delete_folder_files(clusters_root_fol) for cond in conds.keys(): _args = meg.read_cmd_args( dict( subject=args.subject, mri_subject=args.mri_subject, atlas='laus250', function='find_functional_rois_in_stc', inverse_method='MNE', stc_name='{}-MNE-1-15'.format(cond), label_name_template='precentral*', inv_fname='{}-inv'.format(cond), threshold=99.5, min_cluster_max=0.2, min_cluster_size=100, # clusters_label='precentral' )) meg.call_main(_args)
def recon_all_clin(args): # python -m src.preproc.examples.anatomy -s nmr01426 -f recon_all_clin --clin_fol clin_6966926 --dicoms_fol Prisma_fit-67026-20200618-141203-000586 import os for subject, clin_fol, dicoms_fol in zip(args.subject, args.clin_fol, args.dicoms_fol): clin_full_fol = utils.make_dir( op.join(args.clin_root, clin_fol, 'mne_dicom')) memprage_fols = glob.glob(op.join(clin_full_fol, '*MEMPRAGE*')) print('mne_organize_dicom output fol: {}'.format(clin_full_fol)) if len(memprage_fols) > 0: ret = au.is_true( input( 'It seems like you already have memprage folders, are you sure you want to rerun?' )) if not ret: continue utils.delete_folder_files(clin_full_fol) fs_dir = utils.make_dir(op.join(args.fs_root, subject)) print('FreeSurfer output fol: {}'.format(fs_dir)) dicoms_full_path = op.join(args.dicoms_root, dicoms_fol) if not op.isdir(dicoms_full_path): print('{} does not exist!'.format(dicoms_full_path)) continue rs = utils.partial_run_script(locals(), print_only=args.print_only) os.chdir(clin_full_fol) rs('mne_organize_dicom {dicoms_full_path}') anat.recon_all(subject, clin_full_fol, overwrite=True, subjects_dir=args.fs_root, print_only=False, n_jobs=args.n_jobs) args = anat.read_cmd_args( dict( subject=subject, function='all,create_skull_surfaces', remote_subject_dir=op.join(args.fs_root, subject), n_jobs=args.n_jobs, )) pu.run_on_subjects(args, anat.main)
def subcortical_segmentation(subject, overwrite_subcorticals=False, model='subcortical', lookup=None, mask_name='aseg.mgz', mmvt_subcorticals_fol_name='subcortical', template_subject='', norm_name='norm.mgz', overwrite=True): # 1) mri_pretess: Changes region segmentation so that the neighbors of all voxels have a face in common # 2) mri_tessellate: Creates surface by tessellating # 3) mris_smooth: Smooth the new surface # 4) mris_convert: Convert the new surface into srf format template_subject = subject if template_subject == '' else template_subject norm_fname = op.join(SUBJECTS_DIR, template_subject, 'mri', norm_name) if not op.isfile(norm_fname): print('norm file does not exist! {}'.format(norm_fname)) return False mask_fname = op.join(SUBJECTS_DIR, template_subject, 'mri', mask_name) if not op.isfile(mask_fname): print('mask file does not exist! {}'.format(mask_fname)) return False codes_file = op.join(MMVT_DIR, 'sub_cortical_codes.txt') if not op.isfile(codes_file): print('subcortical codes file does not exist! {}'.format(codes_file)) return False # subcortical_lookup = np.genfromtxt(codes_file, dtype=str, delimiter=',') function_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', '{}_objs'.format(model)) utils.make_dir(function_output_fol) renamed_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', model) utils.make_dir(renamed_output_fol) if lookup is None: lookup = load_subcortical_lookup_table() obj_files = glob.glob(op.join(function_output_fol, '*.srf')) errors = [] if len(obj_files) < len(lookup) or overwrite_subcorticals: if overwrite: utils.delete_folder_files(function_output_fol) utils.delete_folder_files(renamed_output_fol) print('Trying to write into {}'.format(function_output_fol)) for region_id in lookup.keys(): if op.isfile(op.join(function_output_fol, '{}.srf'.format(region_id))): continue ret = fu.aseg_to_srf(subject, SUBJECTS_DIR, function_output_fol, region_id, mask_fname, norm_fname, overwrite_subcorticals) if not ret: errors.append(lookup[region_id]) if len(errors) > 0: print('Errors: {}'.format(','.join(errors))) ply_files = glob.glob(op.join(renamed_output_fol, '*.ply')) if len(ply_files) < len(lookup) or overwrite_subcorticals: convert_and_rename_subcortical_files(subject, function_output_fol, renamed_output_fol, lookup, mmvt_subcorticals_fol_name) blender_dir = op.join(MMVT_DIR, subject, mmvt_subcorticals_fol_name) if not op.isdir(blender_dir) or len(glob.glob(op.join(blender_dir, '*.ply'))) < len(ply_files) or overwrite_subcorticals: utils.delete_folder_files(blender_dir) copy_subcorticals_to_mmvt(renamed_output_fol, subject, mmvt_subcorticals_fol_name) flag_ok = len(glob.glob(op.join(blender_dir, '*.ply'))) >= len(lookup) and \ len(glob.glob(op.join(blender_dir, '*.npz'))) >= len(lookup) return flag_ok
def create_functional_rois(subject, contrast_name, clusters_labels_fname='', func_rois_folder=''): if clusters_labels_fname == '': clusters_labels = utils.load( op.join(BLENDER_ROOT_DIR, subject, 'fmri', 'clusters_labels_{}.npy'.format(contrast_name))) if func_rois_folder == '': func_rois_folder = op.join(SUBJECTS_DIR, subject, 'mmvt', 'fmri', 'functional_rois', '{}_labels'.format(contrast_name)) utils.delete_folder_files(func_rois_folder) for cl in clusters_labels: cl_name = 'fmri_{}_{:.2f}'.format(cl['name'], cl['max']) new_label = mne.Label(cl['vertices'], cl['coordinates'], hemi=cl['hemi'], name=cl_name, filename=None, subject=subject, verbose=None) new_label.save(op.join(func_rois_folder, cl_name))
def save_labels_from_vertices_lookup(subject, atlas, subjects_dir, surf_type='pial', read_labels_from_fol=''): # todo: Doens't work on DC, laus250. check that out lookup = create_vertices_labels_lookup( subject, atlas, read_labels_from_fol=read_labels_from_fol) labels_fol = op.join(subjects_dir, subject, 'label', atlas) utils.delete_folder_files(labels_fol) for hemi in utils.HEMIS: labels_vertices = defaultdict(list) surf_fname = op.join(subjects_dir, subject, 'surf', '{}.{}'.format(hemi, surf_type)) surf, _ = mne.surface.read_surface(surf_fname) for vertice, label in lookup[hemi].items(): labels_vertices[label].append(vertice) for label, vertices in labels_vertices.items(): new_label = mne.Label(sorted(vertices), surf[vertices], hemi=hemi, name=label, subject=subject) new_label.save(op.join(labels_fol, label))
def subcortical_segmentation(subject, overwrite_subcortical_objs=False): # Must source freesurfer. You need to have write permissions on SUBJECTS_DIR if not op.isfile(op.join(SUBJECTS_DIR, subject, 'mri', 'norm.mgz')): return False script_fname = op.join(BRAINDER_SCRIPTS_DIR, 'aseg2srf') if not op.isfile(script_fname): raise Exception('The subcortical segmentation script is missing! {}'.format(script_fname)) if not utils.is_exe(script_fname): utils.set_exe_permissions(script_fname) # aseg2srf: For every subcortical region (8 10 11 12 13 16 17 18 26 47 49 50 51 52 53 54 58): # 1) mri_pretess: Changes region segmentation so that the neighbors of all voxels have a face in common # 2) mri_tessellate: Creates surface by tessellating # 3) mris_smooth: Smooth the new surface # 4) mris_convert: Convert the new surface into srf format function_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', 'subcortical_objs') renamed_output_fol = op.join(SUBJECTS_DIR, subject, 'mmvt', 'subcortical') lookup = load_subcortical_lookup_table() obj_files = glob.glob(op.join(function_output_fol, '*.srf')) if len(obj_files) < len(lookup) or overwrite_subcortical_objs: utils.delete_folder_files(function_output_fol) # utils.delete_folder_files(aseg_to_srf_output_fol) utils.delete_folder_files(renamed_output_fol) print('Trying to write into {}'.format(function_output_fol)) utils.run_script(ASEG_TO_SRF.format(subject)) # os.rename(aseg_to_srf_output_fol, function_output_fol) ply_files = glob.glob(op.join(renamed_output_fol, '*.ply')) if len(ply_files) < len(lookup) or overwrite_subcortical_objs: convert_and_rename_subcortical_files(subject, function_output_fol, renamed_output_fol, lookup) blender_dir = op.join(MMVT_DIR, subject, 'subcortical') if not op.isdir(blender_dir) or len(glob.glob(op.join(blender_dir, '*.ply'))) < len(ply_files): copy_subcorticals_to_blender(renamed_output_fol, subject) flag_ok = len(glob.glob(op.join(blender_dir, '*.ply'))) == len(lookup) and \ len(glob.glob(op.join(blender_dir, '*.npz'))) == len(lookup) return flag_ok
def calc_cbf_histograms(subject, scan_rescan, low_threshold, high_threshold, cortex_frac_threshold=0.9, overwrite=False, do_plot=True): subject_fol = op.join(HOME_FOL, site, subject, scan_rescan) output_fol = utils.make_dir( op.join(op.join(RESULTS_FOL, 'aparc_aseg_hists', subject, scan_rescan))) values_output_fname = op.join( op.join(RESULTS_FOL, 'aparc_aseg_hists', subject, scan_rescan, 'aparc_aseg_hist.pkl')) means_output_fname = op.join( op.join(RESULTS_FOL, 'aparc_aseg_hists', subject, scan_rescan, 'aparc_values.pkl')) if op.isfile(values_output_fname) and op.isfile( means_output_fname) and not overwrite and not do_plot: return True cics_cbf_fname = op.join(HOME_FOL, site, subject, scan_rescan, 'CBF.nii') if not op.isfile(cics_cbf_fname): print('calc_cbf_histograms: Cannot find {}!'.format(cics_cbf_fname)) return False aparc_aseg_fname = op.join(subject_fol, 'aparc+aseg_cbf.mgz') if not op.isfile(aparc_aseg_fname): print('calc_cbf_histograms: Cannot find {}!'.format(aparc_aseg_fname)) return False cortex_frac_fname = op.join(HOME_FOL, site, subject, scan_rescan, 'CBF.cortex.mgz') if not op.isfile(cortex_frac_fname): print('No cortex frac!') return False cbf_data = nib.load(cics_cbf_fname).get_data() cortex_frac = nib.load(cortex_frac_fname).get_data() lut = utils.read_freesurfer_lookup_table(return_dict=True) aparc_aseg = nib.load(aparc_aseg_fname).get_data() unique_codes = list(range(1001, 1036)) + list(range(2001, 2036)) if overwrite and do_plot: utils.delete_folder_files(output_fol) regions_values, regions_means = {}, {} output_str = '' for code in tqdm(unique_codes): region_name = lut.get(code, None) if region_name is None: # print('{} not in lut!'.format(code)) continue fig_fname = op.join(output_fol, '{}.jpg'.format(region_name)) if op.isfile(fig_fname) and not overwrite: continue region_values = cbf_data[np.where(aparc_aseg == code)] cortex_frac_values = cortex_frac[np.where(aparc_aseg == code)] cortex_indices = np.where(cortex_frac_values > cortex_frac_threshold) if len(cortex_indices[0]) == 0: output_str += '{} has no voxels with cortex_frac > {}!\n'.format( region_name, cortex_frac_threshold) continue region_values = region_values[cortex_indices] # regions_values[region_name] = region_values.copy() in_bounderies_indices = np.where((low_threshold < region_values) & (region_values < high_threshold)) region_values = region_values[in_bounderies_indices] regions_values[region_name] = region_values.copy() regions_means[region_name] = np.mean(regions_values[region_name]) # if len(outliers) > 0: # output_str += '{} has {} out of {} values < {}\n'.format( # region_name, len(outliers), len(region_values), low_threshold) # outliers = np.where(region_values > high_threshold)[0] # if len(outliers) > 0: # output_str += '{} has {} out of {} values > {}\n'.format( # region_name, len(outliers), len(region_values), high_threshold) # region_values[region_values < low_threshold] = low_threshold # region_values[region_values > high_threshold] = high_threshold if do_plot: plt.hist(region_values, bins=40) plt.savefig(fig_fname) plt.close() print(output_str) utils.save(regions_values, values_output_fname) utils.save(regions_means, means_output_fname)
def language(args): # -f language -s nmr01361 --clinical_dir clin_4090354 # -s nmr01353 -f clean_4d_data --fsd sycabs --remote_fmri_dir "/space/megraid/clinical/MEG-MRI/seder/freesurfer" --nconditions 4 if args.clinical_dir == '': print('You should set the clinical_dir first. Example: clin_4090354') return clinical_root_dir = op.join(args.remote_fmri_dir, args.clinical_dir) if not op.isdir(clinical_root_dir): print('{} does not exist!'.format(clinical_root_dir)) task = 'sycabs' fwhm = 6 subject = args.subject[0] remote_mri_dir = args.remote_clinical_subjects_dir subject_mri_dir = op.join(remote_mri_dir, subject) mri_subject_task_dir = utils.make_dir(op.join(subject_mri_dir, task)) clinical_dirs = glob.glob(op.join(clinical_root_dir, '*')) clinical_dirs = [ d for d in clinical_dirs if utils.namebase(d) != 'mne_dcm' ] remote_fmri_dir = utils.select_one_file(clinical_dirs) fmri_fols = sorted(glob.glob(op.join(remote_fmri_dir, '*_SyCAbs'))) par_fol = utils.make_dir(op.join(remote_mri_dir, subject, 'par')) par_files = glob.glob(op.join(par_fol, '*.par')) sessions = sorted( [utils.find_num_in_str(utils.namebase(d))[0] for d in fmri_fols]) # Warning: You first need to put the original ones in the following folder: if len(par_files) == 0: print('\n *** Please put the original par files in {} and rerun ***'. format(op.join(remote_mri_dir, subject, 'par'))) return par_files.sort(key=lambda x: int(utils.namebase(x).split('_')[-1])) ret = input(''' Patient: {} MRI folder: {} fMRI root folder: {} fMRI sessions: {} Session and pars: {} Do you want to continue (y/n)? '''.format( subject, subject_mri_dir, remote_fmri_dir, [utils.namebase(d) for d in fmri_fols], list(zip([utils.namebase(f) for f in par_files], sessions)))) if not au.is_true(ret): return # You need first to run src.preproc.anatomy if not op.isfile(anat.get_blend_fname(subject, args.atlas)): args = anat.read_cmd_args( dict( subject=subject, remote_subject_dir=subject_mri_dir, ignore_missing=True, )) pu.run_on_subjects(args, anat.main) # convert the fMRI dicom files to nii for fmri_fol in fmri_fols: ses_num = utils.find_num_in_str(utils.namebase(fmri_fol))[0] ses_files = glob.glob(op.join(fmri_fol, '**', '*.*'), recursive=True) output_fname = op.join( utils.make_dir(op.join(mri_subject_task_dir, ses_num)), 'f.nii.gz') if not op.isfile(output_fname): fu.mri_convert(ses_files[0], output_fname) # Convert and arrange the par file from src.misc.fmri_scripts import convert_par for par_file, session in zip(par_files, sessions): fs_par_fname = op.join(mri_subject_task_dir, session, '{}.par'.format(task)) # if not op.isfile(fs_par_fname): warnings = convert_par.sycabs(par_file, fs_par_fname) if warnings != '': print( '\n *** Please fix the problems with the par convertion ({}) and rerun ***\n' .format(par_file)) return for hemi in utils.HEMIS: utils.delete_folder_files( op.join(remote_mri_dir, '{}_sm{}_{}'.format(task, fwhm, hemi))) # Run the FreeSurfer analysis args = fmri.read_cmd_args( dict(subject=subject, atlas=args.atlas, function='clean_4d_data', fsd=task, fwhm=fwhm, remote_fmri_dir=remote_mri_dir, nconditions=4, ignore_missing=True, print_only=False, overwrite_4d_preproc=False)) pu.run_on_subjects(args, fmri.main) # Load the fMRI results args = fmri.read_cmd_args( dict( subject=subject, atlas=args.atlas, function='load_surf_files', fmri_file_template=op.join(MMVT_DIR, subject, 'fmri', 'words_v_symbols_{hemi}.mgz'), )) pu.run_on_subjects(args, fmri.main)
def calc_cortical_histograms(subject, scan_rescan, atlas, low_threshold=40, high_threshold=100, overwrite=False, do_plot=True, n_jobs=4): if not lu.check_labels(subject, atlas, SUBJECTS_DIR, MMVT_DIR): return False output_fol = utils.make_dir( op.join(MMVT_DIR, subject, 'ASL', scan_rescan, 'labels_hists_{}'.format(atlas))) output_fname = op.join(MMVT_DIR, subject, 'ASL', scan_rescan, 'labels_hists_{}.pkl'.format(atlas)) if overwrite: utils.delete_folder_files(output_fol) print('Saving figures into {}'.format(output_fol)) labels_data = {} for hemi in utils.HEMIS: npy_data_fname = op.join( MMVT_DIR, subject, 'fmri', 'fmri_CBF_{}_{}.npy'.format(scan_rescan, hemi)) if not op.isfile(npy_data_fname): print('Cannot find hemi data file! ({})'.format(npy_data_fname)) return False surf_fname = op.join(SUBJECTS_DIR, subject, 'surf', '{}.pial'.format(hemi)) if not op.isfile(surf_fname): print('Cannot find surface file! ({})'.format(surf_fname)) return False hemi_vals = np.load(npy_data_fname) labels = lu.read_labels(subject, SUBJECTS_DIR, atlas, hemi=hemi, n_jobs=n_jobs) labels_vertives_num = max([max(l.vertices) for l in labels]) hemi_data_vertices_num = len(hemi_vals) - 1 if labels_vertives_num != hemi_data_vertices_num: print( 'Wrong number of vertices or labels! labels_vertives_num ({}) != len({})' .format(labels_vertives_num, len(hemi_vals))) return False for label in tqdm(labels): fig_fname = op.join(output_fol, '{}.jpg'.format(label.name)) if op.isfile(fig_fname) and not overwrite: continue labels_data[label.name] = label_data = hemi_vals[label.vertices] outliers = np.where(label_data < low_threshold)[0] if len(outliers) > 0: print('{} has {}/{} values < {}'.format( label.name, len(outliers), len(label_data), low_threshold)) outliers = np.where(label_data > high_threshold)[0] if len(outliers) > 0: print('{} has {}/{} values > {}'.format( label.name, len(outliers), len(label_data), high_threshold)) label_data[label_data < low_threshold] = low_threshold label_data[label_data > high_threshold] = high_threshold if do_plot: plt.hist(label_data, bins=40) plt.savefig(fig_fname) plt.close() utils.save(labels_data, output_fname)