def create_evokeds_links(subject, windows): fol = utils.make_dir(op.join(MMVT_DIR, subject, 'evoked')) for window_fname in windows: new_window_fname = op.join(fol, utils.namebase_with_ext(window_fname)) if op.isfile(new_window_fname) or op.islink(new_window_fname): continue utils.make_link(window_fname, new_window_fname)
def init_meg(subject): utils.make_dir(op.join(MEG_DIR, subject)) utils.make_link( op.join(args.remote_subject_dir.format(subject=subject), 'bem'), op.join(MEG_DIR, subject, 'bem')) utils.make_link(op.join(MEG_DIR, subject, 'bem'), op.join(SUBJECTS_DIR, subject, 'bem'))
def prepare_files(args): ret = {} for subject in args.subject: ret[subject] = True for task in args.tasks: fol = utils.make_dir(op.join(MEG_DIR, task, subject)) local_epo_fname = op.join( fol, '{}_{}_Onset-epo.fif'.format(subject, task)) if not op.isfile(local_epo_fname): remote_epo_fname = op.join( args.meg_dir, subject, '{}_{}_Onset-epo.fif'.format(subject, task)) print('Creating a local link to {}'.format(remote_epo_fname)) utils.make_link(remote_epo_fname, local_epo_fname) local_raw_fname = op.join(fol, '{}_{}-raw.fif'.format(subject, task)) if not op.isfile(local_raw_fname): remote_raw_fname = op.join( utils.get_parent_fol(args.meg_dir), 'ica', subject, '{}_{}-raw.fif'.format(subject, task)) print('Creating a local link to {}'.format(remote_raw_fname)) utils.make_link(remote_raw_fname, local_raw_fname) ret[subject] = ret[subject] and op.isfile( local_epo_fname) and op.isfile(local_raw_fname) print('Good subjects:') print([s for s, r in ret.items() if r]) print('Bad subjects:') print([s for s, r in ret.items() if not r])
def save_subject_ct_trans(subject, ct_name='ct_reg_to_mr.mgz', overwrite=False): output_fname = op.join(MMVT_DIR, subject, 'ct', 'ct_trans.npz') if op.isfile(output_fname) and not overwrite: return True ct_fname, ct_exist = utils.locating_file(ct_name, ['*.mgz', '*.nii', '*.nii.gz'], op.join(MMVT_DIR, subject, 'ct')) # ct_fname = op.join(MMVT_DIR, subject, 'ct', ct_name) if not ct_exist: # op.isfile(ct_fname): # subjects_ct_fname = op.join(SUBJECTS_DIR, subject, 'mri', ct_name) ct_fname, ct_exist = utils.locating_file( ct_name, ['*.mgz', '*.nii', '*.nii.gz'], op.join(SUBJECTS_DIR, subject, 'mri')) if ct_exist: #op.isfile(subjects_ct_fname): utils.make_dir(op.join(MMVT_DIR, subject, 'ct')) ct_fname = utils.copy(ct_fname, op.join(MMVT_DIR, subject, 'ct')) else: print("Can't find subject's CT! ({})".format(ct_fname)) return False if ct_fname != op.join(MMVT_DIR, subject, 'ct', ct_name): utils.make_link(ct_fname, op.join(MMVT_DIR, subject, 'ct', ct_name)) print('save_subject_ct_trans: loading {}'.format(ct_fname)) header = nib.load(ct_fname).header ras_tkr2vox, vox2ras_tkr, vox2ras, ras2vox = anat.get_trans_functions( header) print('save_subject_ct_trans: Saving {}'.format(output_fname)) np.savez(output_fname, ras_tkr2vox=ras_tkr2vox, vox2ras_tkr=vox2ras_tkr, vox2ras=vox2ras, ras2vox=ras2vox) return op.isfile(output_fname)
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 add_reverse_frames_fol(fol, images_prefix, images_type): images = sorted(glob.glob(op.join(fol, '*.{}'.format(images_type))), key=utils.natural_keys) last_frame = int(utils.find_num_in_str(utils.namebase(images[-1]))[0]) for org_frame_ind, new_frame_ind in zip(range(last_frame, -1, -1), range(last_frame + 1, len(images) + last_frame + 1)): org_image_fname = op.join(fol, '{}{}.{}'.format(images_prefix, org_frame_ind, images_type)) new_image_fname = op.join(fol, '{}{}.{}'.format(images_prefix, new_frame_ind, images_type)) if not utils.is_link(org_image_fname): utils.make_link(org_image_fname, new_image_fname)
def prepare_files(args): for subject in args.subject: for task in args.tasks: fol = utils.make_dir(op.join(MEG_DIR, task, subject)) local_fname = op.join(fol, '{}_{}_Onset-epo.fif'.format(subject, task)) if not op.isfile(local_fname): remote_fname = op.join( args.meg_dir, subject, '{}_{}_Onset-epo.fif'.format(subject, task)) utils.make_link(remote_fname, local_fname)
def convert_ct_to_mgz(subject, ct_raw_input_fol, ct_fol='', output_name='ct_org.mgz', overwrite=False, print_only=False, ask_before=False): if not op.isdir(ct_fol): ct_fol = utils.make_dir(op.join(MMVT_DIR, subject, 'ct')) if op.isfile(op.join(ct_fol, 'ct_reg_to_mr.mgz')) and not overwrite: return True if op.isfile(op.join(ct_fol, output_name)): return True ct_fname = utils.select_one_file(glob.glob(op.join(ct_fol, '*.mgz'))) if op.isfile(ct_fname): if utils.namebase(ct_fname) != 'ct_org': utils.make_link(ct_fname, op.join(ct_fol, 'ct_org.mgz')) return True output_fname = op.join(ct_fol, output_name) if op.isfile(output_fname): if not overwrite: return True else: os.remove(output_fname) if op.isfile(op.join(SUBJECTS_DIR, subject, 'ct', 'ct.nii.gz')): ct_files = [op.join(SUBJECTS_DIR, subject, 'ct', 'ct.nii.gz')] elif op.isfile(op.join(SUBJECTS_DIR, subject, 'mri', 'ct.nii.gz')): ct_files = [op.join(SUBJECTS_DIR, subject, 'mri', 'ct.nii.gz')] else: if not op.isdir(ct_raw_input_fol): print('{} does not exist!'.format(ct_fol)) return False ct_files = glob.glob(op.join(ct_raw_input_fol, '*.dcm')) if len(ct_files) == 0: sub_folders = [ d for d in glob.glob(op.join(ct_raw_input_fol, '*')) if op.isdir(d) ] if len(sub_folders) == 0: print('Cannot find CT files in {}!'.format(ct_raw_input_fol)) return False fol = utils.select_one_file(sub_folders, '', 'CT', is_dir=True) ct_files = glob.glob(op.join(fol, '*.dcm')) if len(ct_files) == 0: print('Cannot find CT files in {}!'.format(fol)) return False ct_files.sort(key=op.getmtime) if ask_before: ret = input('convert {} to {}? '.format(ct_files[0], output_fname)) if not au.is_true(ret): return False fu.mri_convert(ct_files[0], output_fname, print_only=print_only) return True if print_only else op.isfile(output_fname)
def get_empty_fnames(subject, tasks, args): utils.make_dir(op.join(MEG_DIR, subject)) utils.make_link(op.join(args.remote_subject_dir.format(subject=subject), 'bem'), op.join(MEG_DIR, subject, 'bem')) for task in tasks: utils.make_dir(op.join(MEG_DIR, task, subject)) utils.make_link(op.join(MEG_DIR, subject, 'bem'), op.join(MEG_DIR, task, subject, 'bem')) utils.make_link(op.join(MEG_DIR, subject, 'bem'), op.join(SUBJECTS_DIR, subject, 'bem')) remote_meg_fol = '/autofs/space/lilli_003/users/DARPA-TRANSFER/meg/{}'.format(subject) csv_fname = op.join(remote_meg_fol, 'cfg.txt') if not op.isfile(csv_fname): print('No cfg file!') return {task:'' for task in tasks} days, empty_fnames = {}, {} for line in utils.csv_file_reader(csv_fname, ' '): for task in tasks: if line[4].lower() == task.lower(): days[task] = line[2] print(days) for line in utils.csv_file_reader(csv_fname, ' '): if line[4] == 'empty': for task in tasks: empty_fnames[task] = op.join(MEG_DIR, task, subject, '{}_empty_raw.fif'.format(subject)) if op.isfile(empty_fnames[task]): continue task_day = days[task] if line[2] == task_day: empty_fname = op.join(remote_meg_fol, line[0].zfill(3), line[-1]) if not op.isfile(empty_fname): raise Exception('empty file does not exist! {}'.format(empty_fname[task])) utils.make_link(empty_fname, empty_fnames[task]) return empty_fnames
def get_empty_fnames(subject, tasks, args, overwrite=False): utils.make_dir(op.join(MEG_DIR, subject)) utils.make_link(op.join(args.remote_subject_dir.format(subject=subject), 'bem'), op.join(MEG_DIR, subject, 'bem'), overwrite=overwrite) for task in tasks: utils.make_dir(op.join(MEG_DIR, task, subject)) utils.make_link(op.join(MEG_DIR, subject, 'bem'), op.join(MEG_DIR, task, subject, 'bem'), overwrite=overwrite) utils.make_link(op.join(MEG_DIR, subject, 'bem'), op.join(SUBJECTS_DIR, subject, 'bem'), overwrite=overwrite) remote_meg_fol = op.join(args.remote_meg_dir, subject) csv_fname = op.join(remote_meg_fol, 'cfg.txt') empty_fnames, cors, days = '', '', '' if not op.isfile(csv_fname): print('No cfg file!') return '', '', '' days, empty_fnames, cors = {}, {}, {} for line in utils.csv_file_reader(csv_fname, ' '): for task in tasks: if line[4].lower() == task.lower(): days[task] = line[2] # print(days) for line in utils.csv_file_reader(csv_fname, ' '): if line[4] == 'empty': for task in tasks: empty_fnames[task] = op.join( MEG_DIR, task, subject, '{}_empty_raw.fif'.format(subject)) if op.isfile(empty_fnames[task]): continue task_day = days[task] if line[2] == task_day: empty_fname = op.join(remote_meg_fol, line[0].zfill(3), line[-1]) if not op.isfile(empty_fname): raise Exception('empty file does not exist! {}'.format( empty_fname[task])) utils.make_link(empty_fname, empty_fnames[task]) cor_dir = op.join(args.remote_subject_dir.format(subject=subject), 'mri', 'T1-neuromag', 'sets') for task in tasks: if op.isfile( op.join(cor_dir, 'COR-{}-{}.fif'.format(subject, task.lower()))): cors[task] = op.join( cor_dir, 'COR-{}-{}.fif'.format('{subject}', task.lower())) elif op.isfile( op.join(cor_dir, 'COR-{}-day{}.fif'.format(subject, days[task]))): cors[task] = op.join( cor_dir, 'COR-{}-day{}.fif'.format('{subject}', days[task])) return empty_fnames, cors, days
def project_cbf_on_cortex(subject, site, scan_rescan, overwrite=False, print_only=False): mmvt_subject = subject if scan_rescan == SCAN else '{}_rescan'.format( subject) fmri_fol = utils.make_dir(op.join(FMRI_DIR, mmvt_subject)) mmvt_cbf_fname = op.join(fmri_fol, 'CBF_{}.nii'.format(scan_rescan)) cics_cbf_fname = op.join(HOME_FOL, site, subject, scan_rescan, 'CBF.nii') reg_file = op.join(HOME_FOL, site, subject, scan_rescan, 'control_to_T1.lta') if not op.islink(mmvt_cbf_fname) and op.isfile(cics_cbf_fname): utils.make_link(cics_cbf_fname, mmvt_cbf_fname) if not op.islink(mmvt_cbf_fname): print('Cannot file the link to CBF! ({}-{})'.format( cics_cbf_fname, mmvt_cbf_fname)) return False if not op.isfile(reg_file): print('Cannot find the registration file! ({})'.format(reg_file)) return False verts = utils.load_surf(subject, MMVT_DIR, SUBJECTS_DIR) for hemi in utils.HEMIS: surf_output_fname = op.join(FMRI_DIR, subject, 'CBF_{}_{}.mgz'.format(scan_rescan, hemi)) npy_output_fname = op.join( MMVT_DIR, subject, 'fmri', 'fmri_CBF_{}_{}.npy'.format(scan_rescan, hemi)) if op.isfile(npy_output_fname) and not overwrite: continue fu.project_volume_data(cics_cbf_fname, hemi, reg_file=reg_file, smooth_fwhm=0, output_fname=surf_output_fname, print_only=print_only) if print_only: continue surf_data = np.squeeze(nib.load(surf_output_fname).get_data()) np.save(npy_output_fname, surf_data) if len(verts[hemi]) != len(surf_data): print( '*** Wrong number of vertices in {} data! surf vertices ({}) != data vertices ({})' .format(hemi, len(verts[hemi]), len(surf_data)))
def _plot_evokes_parallel(p): subject, modality, window_fname, bad_channels, figs_fol, overwrite = p module = eeg if modality == 'eeg' else meg window = utils.namebase(window_fname) evo_fname = op.join(MMVT_DIR, subject, 'evoked', '{}.fif'.format(window)) if not op.isfile(evo_fname): utils.make_link(window_fname, evo_fname) fig_fname = op.join(figs_fol, '{}.jpg'.format(window)) if op.isfile(fig_fname) and not overwrite: return if bad_channels != 'bads': bad_channels = bad_channels.split(',') module.plot_evoked(subject, evo_fname, window_title=window, exclude=bad_channels, save_fig=True, fig_fname=fig_fname, overwrite=overwrite)
def prepare_files(args): # todo: should look in the dict for files locations ret = {} for subject in args.subject: ret[subject] = True for task in args.tasks: fol = utils.make_dir(op.join(MEG_DIR, task, subject)) local_epo_fname = op.join( fol, '{}_{}_Onset-epo.fif'.format(subject, task)) local_raw_fname = op.join(fol, '{}_{}-raw.fif'.format(subject, task)) if not args.overwrite and (op.islink(local_epo_fname) or op.isfile(local_epo_fname)) and \ (op.islink(local_raw_fname) or op.isfile(local_raw_fname)): continue if op.islink(local_epo_fname) or op.isfile(local_epo_fname): os.remove(local_epo_fname) remote_epo_fname = op.join( args.meg_dir, subject, '{}_{}_meg_Onset-epo.fif'.format(subject, task)) if not op.isfile(remote_epo_fname): print('{} does not exist!'.format(remote_epo_fname)) ret[subject] = False continue print('Creating a local link to {}'.format(remote_epo_fname)) utils.make_link(remote_epo_fname, local_epo_fname) if op.islink(local_raw_fname) or op.isfile(local_raw_fname): os.remove(local_raw_fname) remote_raw_fname = op.join( utils.get_parent_fol(args.meg_dir), 'raw_preprocessed', subject, '{}_{}_meg_ica-raw.fif'.format(subject, task)) if not op.isfile(remote_epo_fname): print('{} does not exist!'.format(remote_raw_fname)) ret[subject] = False continue print('Creating a local link to {}'.format(remote_raw_fname)) utils.make_link(remote_raw_fname, local_raw_fname) ret[subject] = ret[subject] and (op.isfile(local_epo_fname) or op.islink(local_epo_fname)) and \ (op.isfile(local_raw_fname) or op.islink(local_raw_fname)) print('Good subjects:') print([s for s, r in ret.items() if r]) print('Bad subjects:') print([s for s, r in ret.items() if not r])
def get_meg_empty_fnames(subject, remote_fol, args): csv_fname = op.join(remote_fol, 'cfg.txt') if not op.isfile(csv_fname): print('No cfg file!') return '', '', '' day, empty_fname, cor_fname, local_rest_raw_fname = '', '', '', '' for line in utils.csv_file_reader(csv_fname, ' '): if line[4].lower() == 'resting': day = line[2] remote_rest_raw_fname = op.join(remote_fol, line[0].zfill(3), line[-1]) if not op.isfile(remote_rest_raw_fname): raise Exception('rest file does not exist! {}'.format( remote_rest_raw_fname)) local_rest_raw_fname = op.join( MEG_DIR, subject, '{}_resting_raw.fif'.format(subject)) if not op.isfile(local_rest_raw_fname): utils.make_link(remote_rest_raw_fname, local_rest_raw_fname) break if day == '': print('Couldn\'t find the resting day in the cfg!') return '', '', '' for line in utils.csv_file_reader(csv_fname, ' '): if line[4] == 'empty': empty_fname = op.join(MEG_DIR, subject, '{}_empty_raw.fif'.format(subject)) if op.isfile(empty_fname): continue if line[2] == day: remote_empty_fname = op.join(remote_fol, line[0].zfill(3), line[-1]) if not op.isfile(remote_empty_fname): raise Exception('empty file does not exist! {}'.format( remote_empty_fname)) utils.make_link(remote_empty_fname, empty_fname) cor_dir = op.join(args.remote_subject_dir.format(subject=subject), 'mri', 'T1-neuromag', 'sets') if op.isfile(op.join(cor_dir, 'COR-{}-resting.fif'.format(subject))): cor_fname = op.join(cor_dir, 'COR-{}-resting.fif'.format(subject)) elif op.isfile(op.join(cor_dir, 'COR-{}-day{}.fif'.format(subject, day))): cor_fname = op.join(cor_dir, 'COR-{}-day{}.fif'.format(subject, day)) return local_rest_raw_fname, empty_fname, cor_fname
def _plot_topomaps_parallel(p): subject, modality, window_fname, bad_channels, figs_fol = p module = eeg if modality == 'eeg' else meg window = utils.namebase(window_fname) evo_fname = op.join(MMVT_DIR, subject, 'evoked', '{}.fif'.format(window)) if not op.isfile(evo_fname): utils.make_link(window_fname, evo_fname) fig_fname = op.join(figs_fol, '{}.jpg'.format(window)) if op.isfile(fig_fname): return # if bad_channels != 'bads': # bad_channels = bad_channels.split(',') module.plot_topomap(subject, evo_fname, times=[0], find_peaks=True, same_peaks=False, n_peaks=5, bad_channels=bad_channels, title=window, save_fig=True, fig_fname=fig_fname)
def meg_preproc_power(args): inv_method, em, atlas = 'dSPM', 'mean_flip', 'laus125' # 'darpa_atlas' # bands = dict(theta=[4, 8], alpha=[8, 15], beta=[15, 30], gamma=[30, 55], high_gamma=[65, 200]) times = (-2, 4) subjects_with_error = [] good_subjects = get_good_subjects(args) args.subject = good_subjects prepare_files(args) for subject in good_subjects: args.subject = subject empty_fnames, cors, days = get_empty_fnames(subject, args.tasks, args) input_fol = utils.make_dir( op.join(MEG_DIR, subject, 'labels_induced_power')) for task in args.tasks: # output_fname = op.join( # MMVT_DIR, subject, 'meg', '{}_{}_{}_power_spectrum.npz'.format(task.lower(), inv_method, em)) # if op.isfile(output_fname) and args.check_file_modification_time: # file_mod_time = utils.file_modification_time_struct(output_fname) # if file_mod_time.tm_year >= 2018 and (file_mod_time.tm_mon == 9 and file_mod_time.tm_mday >= 21) or \ # (file_mod_time.tm_mon > 9): # print('{} already exist!'.format(output_fname)) # continue input_fnames = glob.glob( op.join( input_fol, '{}_*_{}_{}_{}_induced_power.npz'.format( task.lower(), atlas, inv_method, em))) if len(input_fnames) == 28: print('{} has already all the results for {}'.format( subject, task)) continue remote_epo_fname = op.join( args.meg_dir, subject, args.epo_template.format(subject=subject, task=task)) local_epo_fname = op.join( MEG_DIR, task, subject, args.epo_template.format(subject=subject, task=task)) if not op.isfile(local_epo_fname) and not op.isfile( remote_epo_fname): print('Can\'t find {}!'.format(local_epo_fname)) continue if not op.isfile(local_epo_fname): utils.make_link(remote_epo_fname, local_epo_fname) meg_args = meg.read_cmd_args( dict( subject=args.subject, mri_subject=args.subject, task=task, inverse_method=inv_method, extract_mode=em, atlas=atlas, # meg_dir=args.meg_dir, remote_subject_dir=args. remote_subject_dir, # Needed for finding COR get_task_defaults=False, fname_format='{}_{}_Onset'.format('{subject}', task), raw_fname=op.join(MEG_DIR, task, subject, '{}_{}-raw.fif'.format(subject, task)), epo_fname=local_epo_fname, empty_fname=empty_fnames[task] if empty_fnames != '' else '', function= 'make_forward_solution,calc_inverse_operator,calc_labels_induced_power', #, conditions=task.lower(), cor_fname=cors[task].format( subject=subject) if cors != '' else '', average_per_event=False, data_per_task=True, pick_ori= 'normal', # very important for calculation of the power spectrum # fmin=4, fmax=120, bandwidth=2.0, max_epochs_num=args.max_epochs_num, ica_overwrite_raw=False, normalize_data=False, fwd_recreate_source_space=True, t_min=times[0], t_max=times[1], read_events_from_file=False, stim_channels='STI001', use_empty_room_for_noise_cov=True, read_only_from_annot=False, # pick_ori='normal', overwrite_labels_power_spectrum=args. overwrite_labels_power_spectrum, overwrite_evoked=args.overwrite, overwrite_fwd=args.overwrite, overwrite_inv=args.overwrite, overwrite_stc=args.overwrite, overwrite_labels_data=args.overwrite, n_jobs=args.n_jobs)) ret = meg.call_main(meg_args) output_fol = utils.make_dir( op.join(MMVT_DIR, subject, 'labels', 'labels_data')) join_res_fol = utils.make_dir( op.join(utils.get_parent_fol(MMVT_DIR), 'msit-ecr', subject)) for res_fname in glob.glob( op.join( output_fol, '{}_labels_{}_{}_*_power.npz'.format( task.lower(), inv_method, em))): shutil.copyfile( res_fname, op.join(join_res_fol, utils.namebase_with_ext(res_fname))) if not ret: if args.throw: raise Exception("errors!") else: subjects_with_error.append(subject) good_subjects = [ s for s in good_subjects if op.isfile( op.join( MMVT_DIR, subject, 'meg', 'labels_data_msit_{}_{}_{}_minmax.npz'.format( atlas, inv_method, em))) and op.isfile( op.join( MMVT_DIR, subject, 'meg', 'labels_data_ecr_{}_{}_{}_minmax.npz' .format(atlas, inv_method, em))) ] print('Good subjects:') print(good_subjects) print('subjects_with_error:') print(subjects_with_error)
def calc_meg_connectivity(args): inv_method, em = 'dSPM', 'mean_flip' prepare_files(args) good_subjects = get_good_subjects(args) args.subject = good_subjects for subject in good_subjects: args.subject = subject for task in args.tasks: output_fname = op.join( MMVT_DIR, subject, 'connectivity', '{}_{}_coh_cwt_morlet.npz'.format(task.lower(), em)) if op.isfile(output_fname): file_mod_time = utils.file_modification_time_struct( output_fname) if file_mod_time.tm_year >= 2018 and (file_mod_time.tm_mon == 10 and file_mod_time.tm_mday >= 10) or \ (file_mod_time.tm_mon > 10): print('{} already exist!'.format(output_fname)) continue remote_epo_fname = op.join( args.meg_dir, subject, args.epo_template.format(subject=subject, task=task)) local_epo_fname = op.join( MEG_DIR, task, subject, args.epo_template.format(subject=subject, task=task)) if not op.isfile(local_epo_fname): utils.make_link(remote_epo_fname, local_epo_fname) con_args = meg.read_cmd_args( utils.Bag( subject=args.subject, mri_subject=args.subject, task=task, inverse_method=inv_method, extract_mode=em, atlas=args.atlas, # meg_dir=args.meg_dir, remote_subject_dir=args. remote_subject_dir, # Needed for finding COR get_task_defaults=False, data_per_task=True, fname_format='{}_{}_Onset'.format('{subject}', task), raw_fname=op.join(MEG_DIR, task, subject, '{}_{}-raw.fif'.format(subject, task)), epo_fname=local_epo_fname, # empty_fname=empty_fnames[task], function='calc_labels_connectivity', conditions=task.lower(), overwrite_connectivity=True, #args.overwrite_connectivity, # cor_fname=cors[task].format(subject=subject), # ica_overwrite_raw=False, # normalize_data=False, # t_min=times[0], t_max=times[1], # read_events_from_file=False, stim_channels='STI001', # use_empty_room_for_noise_cov=True, # read_only_from_annot=False, # pick_ori='normal', # overwrite_evoked=args.overwrite, # overwrite_inv=args.overwrite, # overwrite_stc=args.overwrite, # overwrite_labels_data=args.overwrite, n_jobs=args.n_jobs)) meg.call_main(con_args)
def arrange_data(subjects): files_list = [] for sub in subjects: utils.make_dir(op.join(fmri_root_data, sub)) sub_root_anat_fol = utils.make_dir(op.join(fmri_root_data, sub, 'anat')) sub_root_bold_fol = utils.make_dir(op.join(fmri_root_data, sub, 'bold')) anat_fols = [ f for f in glob.glob(op.join(subject_fmri_fold, sub, 'anat', '*')) if op.isdir(f) ] if len(anat_fols) == 0: print('No anat folder for {}!'.format(sub)) continue elif len(anat_fols) > 1: print('More than one anat folder for {}!'.format(sub)) continue anat_fol = anat_fols[0] anat_number = int(utils.namebase(anat_fol)) anat_files = glob.glob(op.join(anat_fol, '*nii.gz')) if len(anat_files) == 1: sub_anat_fol = utils.make_dir( op.join(sub_root_anat_fol, utils.namebase(anat_fol))) utils.make_link( anat_files[0], op.join(sub_anat_fol, '{}.nii.gz'.format(utils.namebase(anat_files[0])))) elif len(anat_files) == 0: print('No nii.gz files were found in {}!'.format(anat_fol)) continue else: print('Too many nii.gz files were found in {}!'.format(anat_fol)) continue bold_fols = [ f for f in glob.glob(op.join(subject_fmri_fold, sub, 'bold', '*')) if op.isdir(f) ] bolds_numbers = ','.join( [str(int(utils.namebase(bold_fol))) for bold_fol in bold_fols]) for bold_fol in bold_fols: fmri_files = glob.glob( op.join(bold_fol, '*.nii') ) # '{}_bld{}_rest.nii'.format(sub, utils.namebase(bold_fol)))) if len(fmri_files) == 1: sub_fmri_fol = utils.make_dir( op.join(sub_root_bold_fol, utils.namebase(bold_fol))) # utils.delete_folder_files(sub_fmri_fol) # target_file = op.join(sub_fmri_fol, '{}_bld{}_rest_reorient.nii.gz'.format(sub, utils.namebase(bold_fol))) target_file = op.join( sub_fmri_fol, '{}_bld{}_rest.nii'.format(sub, utils.namebase(bold_fol))) utils.make_link(fmri_files[0], target_file) new_target_file = op.join( sub_fmri_fol, '{}_bld{}_rest_reorient.nii.gz'.format( sub, utils.namebase(bold_fol))) if not op.isfile(new_target_file): output = utils.run_script('mri_convert {} {}'.format( target_file, new_target_file)) # utils.remove_link(target_file) # if not op.isfile(target_file): # utils.copy_file(fmri_files[0], target_file) elif len(fmri_files) == 0: print( 'No *_rest_reorient_skip_faln_mc.nii.gz files were found in {}!' .format(bold_fol)) continue else: print( 'Too many *_rest_reorient_skip_faln_mc.nii.gz files were found in {}!' .format(bold_fol)) continue tr = int(fu.get_tr(target_file) * 1000) / 1000.0 files_list.append('{} {} {} {}'.format( sub, bolds_numbers, str(anat_number).zfill(3), tr)) #int(tr))) # int(trs[sub]))) utils.make_dir(op.join(fmri_root_data, sub, 'scripts')) params_fname = op.join(fmri_root_data, sub, 'scripts', '{}.params'.format(sub)) with open(params_fname, 'w') as f: f.write( params_file_text.format(subject=sub, bolds=bolds_numbers.replace(',', ' '), tr=tr)) return files_list
def calc_meg_source_psd(args): from src.misc import meg_buddy bad_subjects = ['hc004', 'hc012', 'hc029'] subjects = args.subject for subject in subjects: if subject in bad_subjects: continue fol = op.join(MMVT_DIR, subject, 'meg') file_name = '{cond}_dSPM_mean_flip_vertices_power_spectrum.pkl' if all([op.isfile(op.join(fol, file_name.format(cond=cond.lower()))) for cond in MSIT_CONDS]) and not args.overwrite: print('{}: already has MSIT power stcs'.format(subject)) continue args.subject = subject local_raw_fname = op.join(MEG_DIR, args.task, subject, args.raw_template.format( subject=subject, task=args.task)) remote_raw_fname = op.join(args.remote_root_dir, 'raw_preprocessed', subject, args.raw_template.format( subject=subject, task=args.task)) if not op.isfile(remote_raw_fname) and not args.ignore: print('Can\'t find remote raw file! {}'.format(remote_raw_fname)) continue if op.isfile(local_raw_fname): os.remove(local_raw_fname) utils.make_link(remote_raw_fname, local_raw_fname) if not op.islink(local_raw_fname) and not args.ignore: print('Can\'t create a link to the remote raw!') continue inv_fname = op.join(MEG_DIR, args.task, subject, args.inv_template.format(subject=subject, task=args.task)) if not op.isfile(inv_fname): inv_fnames = glob.glob(op.join(MEG_DIR, args.task, subject, '*inv.fif')) if len(inv_fnames) > 0: inv_fname = utils.select_one_file(inv_fnames) print('New inv fname: {}'.format(inv_fname)) _args = meg.read_cmd_args(dict( subject=subject, mri_subject=subject, function='make_forward_solution,calc_inverse_operator', task='MSIT', data_per_task=True, fmin=1, fmax=120, raw_fname=local_raw_fname, inv_fname=inv_fname, remote_subject_dir=args.remote_subject_dir, n_jobs=args.n_jobs )) ret = meg.call_main(_args) if not ret[subject].get('calc_inverse_operator', True): continue # Load the eopchs and calc source power spectrum for both conditions. # The epochs are being splitted first data = meg_buddy.get_data(subject, tasks=['MSIT'], modalities=['MEG'])['MSIT']['MEG'] if subject not in data: print('{} not in msit_data!'.format(subject)) continue data = data[subject] subject_epochs = data._load_epochs('Onset', ar=True) indices = data._get_indices(subject_epochs, 'Condition', MSIT_CONDS) for cond in MSIT_CONDS: epochs = subject_epochs[indices[cond]] meg.calc_source_power_spectrum( subject, cond.lower(), epochs=epochs, max_epochs_num=50, inv_fname=inv_fname, overwrite=args.overwrite, n_jobs=args.n_jobs)
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))