def main(): arguments = docopt(__doc__) verbose = arguments['--verbose'] debug = arguments['--debug'] DRYRUN = arguments['--dry-run'] ch = logging.StreamHandler() ch.setLevel(logging.WARNING) if verbose: ch.setLevel(logging.INFO) if debug: ch.setLevel(logging.DEBUG) formatter = logging.Formatter('%(message)s') ch.setFormatter(formatter) logger.addHandler(ch) # Get settings, and add an extra handler for the current log settings = Settings(arguments) fh = settings.get_log_handler(formatter) logger.addHandler(fh) logger.info('{}{}'.format(ciftify.utils.ciftify_logo(), section_header("Starting ciftify_subject_fmri"))) with ciftify.utils.TempDir() as tmpdir: logger.info('Creating tempdir:{} on host:{}'.format(tmpdir, os.uname()[1])) ret = run_ciftify_subject_fmri(settings, tmpdir) logger.info(section_header("Done")) sys.exit(ret)
def main(): arguments = docopt(__doc__) verbose = arguments['--verbose'] debug = arguments['--debug'] DRYRUN = arguments['--dry-run'] if arguments['--ciftify-work-dir']: WorkDir = arguments['--ciftify-work-dir'] else: WorkDir = arguments["--hcp-data-dir"] Subject = arguments["<subject>"] NameOffMRI = arguments["<task_label>"] if WorkDir == None: WorkDir = ciftify.config.find_work_dir() if not os.path.exists(os.path.join(WorkDir, Subject, 'MNINonLinear')): sys.exit( "The subject's working directory not found. Note that ciftify_recon_all needs to be run perfore this step." ) ch = logging.StreamHandler() ch.setLevel(logging.WARNING) if verbose: ch.setLevel(logging.INFO) if debug: ch.setLevel(logging.DEBUG) formatter = logging.Formatter('%(message)s') ch.setFormatter(formatter) logger.addHandler(ch) # Get settings, and add an extra handler for the subject log local_logpath = os.path.join(WorkDir, Subject, 'MNINonLinear', 'Results', NameOffMRI) logfile = os.path.join(local_logpath, 'ciftify_subject_fmri.log') if os.path.exists(logfile): logger.error( 'Subject output already exits.\n To force rerun, delete or rename the logfile:\n\t{}' .format(logfile)) sys.exit(1) if not os.path.exists(local_logpath): os.mkdir(local_logpath) fh = logging.FileHandler(logfile) fh.setLevel(logging.INFO) fh.setFormatter(formatter) logger.addHandler(fh) logger.info('{}{}'.format(ciftify.utils.ciftify_logo(), section_header("Starting ciftify_subject_fmri"))) with ciftify.utils.TempDir() as tmpdir: logger.info('Creating tempdir:{} on host:{}'.format( tmpdir, os.uname()[1])) ret = run_ciftify_subject_fmri(arguments, tmpdir) logger.info(section_header("Done")) sys.exit(ret)
def define_func_3D(settings, tmpdir): """ create the func_3D file as per subject instrutions """ logger.info(section_header("Getting fMRI reference volume")) if settings.func_ref.mode == "first_vol": '''take the fist image (default)''' native_func_3D = os.path.join(tmpdir, "native_func_first.nii.gz") run(['wb_command', '-volume-math "(x)"', native_func_3D, '-var','x', settings.func_4D, '-subvolume', '1']) elif settings.func_ref.mode == "median": '''take the median over time, if indicated''' native_func_3D = os.path.join(tmpdir, "native_func_median.nii.gz") run(['wb_command', '-volume-reduce', settings.func_4D, 'MEDIAN', native_func_3D]) elif settings.func_ref.mode == "path": '''use the file indicated by the user..after checking the dimension''' ciftify.meants.verify_nifti_dimensions_match(settings.func_ref.path, settings.func_4D) native_func_3D = settings.func_ref.path else: sys.exit('Failed to define the ref volume') return native_func_3D
def copy_atlas_images(settings): ''' behaviour (instead of flirt) is the data is already in atlas atlas space For the 4D nifti input --> just copy For the 3D nifti input --> ensure it matches the spacing of the fMRI and copy ''' logger.info(section_header("Copying MNI space input fMRI")) atlas_fMRI_4D = os.path.join(settings.results_dir, '{}.nii.gz'.format(settings.fmri_label)) atlas_fMRI_3D = os.path.join(settings.diagnostics.path, 'func_reference.nii.gz') run(['cp', settings.func_4D, atlas_fMRI_4D]) if settings.func_ref.mode == "first_vol": '''take the fist image (default)''' run(['wb_command', '-volume-math "(x)"', atlas_fMRI_3D, '-var','x', settings.func_4D, '-subvolume', '1']) elif settings.func_ref.mode == "median": '''take the median over time, if indicated''' run(['wb_command', '-volume-reduce', settings.func_4D, 'MEDIAN', atlas_fMRI_3D]) elif settings.func_ref.mode == "path": '''use the file indicated by the user..after checking the dimension''' cifify.meants.verify_nifti_dimensions_match(settings.ref_vol.path, settings.func_4D) atlas_fMRI_3D = settings.func_ref.path else: sys.exit('Failed to define the ref volume') return atlas_fMRI_4D, atlas_fMRI_3D
def main(): global DRYRUN arguments = docopt(__doc__) verbose = arguments['--verbose'] debug = arguments['--debug'] DRYRUN = arguments['--dry-run'] ch = logging.StreamHandler() ch.setLevel(logging.WARNING) if verbose: ch.setLevel(logging.INFO) if debug: ch.setLevel(logging.DEBUG) formatter = logging.Formatter('%(message)s') ch.setFormatter(formatter) logger.addHandler(ch) # Get settings, and add an extra handler for the current log settings = Settings(arguments) logger.info('{}'.format(ciftify.utils.ciftify_logo())) if settings.analysis_level == "group": logger.info(section_header("Starting ciftify group")) ret = run_group_workflow(settings) if settings.analysis_level == "participant": logger.info(section_header("Starting ciftify participant")) ret = run_participant_workflow(settings) logger.info(section_header("Done")) sys.exit(ret)
def run_ciftify_subject_fmri(arguments, tmpdir): input_fMRI = arguments["<func.nii.gz>"] if arguments['--ciftify-work-dir']: WorkDir = arguments['--ciftify-work-dir'] else: WorkDir = arguments["--hcp-data-dir"] Subject = arguments["<Subject>"] NameOffMRI = arguments["<NameOffMRI>"] SmoothingFWHM = arguments["--SmoothingFWHM"] DilateBelowPct = arguments["--DilateBelowPct"] OutputSurfDiagnostics = arguments['--OutputSurfDiagnostics'] noMNItransform = arguments['--already-in-MNI'] RegTemplate = arguments['--FLIRT-template'] FLIRT_dof = arguments['--FLIRT-dof'] FLIRT_cost = arguments['--FLIRT-cost'] reg_name = arguments['--reg-name'] if WorkDir == None: WorkDir = ciftify.config.find_work_dir() ## write a bunch of info about the environment to the logs log_build_environment() logger.info('Arguments:') logger.info("\tinput_fMRI: {}".format(input_fMRI)) if not os.path.isfile(input_fMRI): logger.error("input_fMRI does not exist :(..Exiting") sys.exit(1) logger.info("\tHCP_DATA: {}".format(WorkDir)) logger.info("\tSubject: {}".format(Subject)) logger.info("\tNameOffMRI: {}".format(NameOffMRI)) logger.info("\tSurface Registration: {}".format(reg_name)) if reg_name == "MSMSulc": RegName = "MSMSulc" elif reg_name == "FS": RegName = "reg.reg_LR" else: logger.critical('--reg-name argument must be "FS" or "MSMSulc"') sys.exit(1) if SmoothingFWHM: logger.info("\tSmoothingFWHM: {}".format(SmoothingFWHM)) if DilateBelowPct: logger.info( "\tWill fill holes defined as data with intensity below {} percentile" .format(DilateBelowPct)) # Setup PATHS GrayordinatesResolution = "2" LowResMesh = "32" DilateFactor = "10" #Templates and settings AtlasSpaceFolder = os.path.join(WorkDir, Subject, "MNINonLinear") DownSampleFolder = os.path.join(AtlasSpaceFolder, "fsaverage_LR32k") ResultsFolder = os.path.join(AtlasSpaceFolder, "Results", NameOffMRI) AtlasSpaceNativeFolder = os.path.join(AtlasSpaceFolder, "Native") logger.info("The following settings are set by default:") logger.info( "\nGrayordinatesResolution: {}".format(GrayordinatesResolution)) logger.info('\nLowResMesh: {}k'.format(LowResMesh)) logger.info( 'Native space surfaces are in: {}'.format(AtlasSpaceNativeFolder)) L_sphere = os.path.join( AtlasSpaceNativeFolder, '{}.L.sphere.{}.native.surf.gii'.format(Subject, RegName)) if not os.path.exists(L_sphere): logger.critical("Registration Sphere {} not found".format(L_sphere)) sys.exit(1) logger.info( 'The resampled surfaces (those matching the final result are in: {})'. format(DownSampleFolder)) # PipelineScripts=${HCPPIPEDIR_fMRISurf} input_fMRI_4D = os.path.join(ResultsFolder, '{}.nii.gz'.format(NameOffMRI)) input_fMRI_3D = os.path.join(tmpdir, '{}_Mean.nii.gz'.format(NameOffMRI)) # output files if OutputSurfDiagnostics: DiagnosticsFolder = os.path.join(ResultsFolder, 'RibbonVolumeToSurfaceMapping') logger.info("Diagnostic Files will be written to: {}".format( DiagnosticsFolder)) run(['mkdir', '-p', DiagnosticsFolder]) else: DiagnosticsFolder = tmpdir ###### from end of volume mapping pipeline ## copy inputs into the ResultsFolder run(['mkdir', '-p', ResultsFolder]) ## read the number of TR's and the TR from the header TR_num = first_word(get_stdout(['fslval', input_fMRI, 'dim4'])) logger.info('Number of TRs: {}'.format(TR_num)) MiddleTR = int(TR_num) // 2 logger.info('Middle TR: {}'.format(MiddleTR)) TR_vol = first_word(get_stdout(['fslval', input_fMRI, 'pixdim4'])) logger.info('TR(ms): {}'.format(TR_vol)) ## either transform or copy the input_fMRI if noMNItransform: run(['cp', input_fMRI, input_fMRI_4D]) else: logger.info(section_header('MNI Transform')) logger.info( 'Running transform to MNIspace with costfunction {} and dof {}'. format(FLIRT_cost, FLIRT_dof)) transform_to_MNI(input_fMRI, input_fMRI_4D, FLIRT_cost, FLIRT_dof, WorkDir, Subject, RegTemplate, tmpdir) #Make fMRI Ribbon #Noisy Voxel Outlier Exclusion #Ribbon-based Volume to Surface mapping and resampling to standard surface logger.info(section_header('Making fMRI Ribbon')) run(['fslmaths', input_fMRI_4D, '-Tmean', input_fMRI_3D]) ribbon_vol = os.path.join(DiagnosticsFolder, 'ribbon_only.nii.gz') make_cortical_ribbon(Subject, AtlasSpaceNativeFolder, input_fMRI_3D, ribbon_vol) goodvoxels_vol = os.path.join(DiagnosticsFolder, 'goodvoxels.nii.gz') tmean_vol, cov_vol = define_good_voxels(input_fMRI_4D, ribbon_vol, goodvoxels_vol, tmpdir) logger.info(section_header('Mapping fMRI to 32k Surface')) for Hemisphere in ["L", "R"]: ## the input surfaces for this section in the AtlasSpaceNativeFolder mid_surf_native = os.path.join( AtlasSpaceNativeFolder, '{}.{}.midthickness.native.surf.gii'.format(Subject, Hemisphere)) pial_surf = os.path.join( AtlasSpaceNativeFolder, '{}.{}.pial.native.surf.gii'.format(Subject, Hemisphere)) white_surf = os.path.join( AtlasSpaceNativeFolder, '{}.{}.white.native.surf.gii'.format(Subject, Hemisphere)) roi_native_gii = os.path.join( AtlasSpaceNativeFolder, '{}.{}.roi.native.shape.gii'.format(Subject, Hemisphere)) sphere_reg_native = os.path.join( AtlasSpaceNativeFolder, '{}.{}.sphere.{}.native.surf.gii'.format(Subject, Hemisphere, RegName)) ## the inputs for this section from the DownSampleFolder mid_surf_32k = os.path.join( DownSampleFolder, '{}.{}.midthickness.{}k_fs_LR.surf.gii'.format( Subject, Hemisphere, LowResMesh)) roi_32k_gii = os.path.join( DownSampleFolder, '{}.{}.atlasroi.{}k_fs_LR.shape.gii'.format( Subject, Hemisphere, LowResMesh)) sphere_reg_32k = os.path.join( DownSampleFolder, '{}.{}.sphere.{}k_fs_LR.surf.gii'.format(Subject, Hemisphere, LowResMesh)) ## now finally, actually project the fMRI input input_func_native = os.path.join( tmpdir, '{}.{}.native.func.gii'.format(NameOffMRI, Hemisphere)) run([ 'wb_command', '-volume-to-surface-mapping', input_fMRI_4D, mid_surf_native, input_func_native, '-ribbon-constrained', white_surf, pial_surf, '-volume-roi', goodvoxels_vol ]) ## dilate to get rid of wholes caused by the goodvoxels_vol mask run([ 'wb_command', '-metric-dilate', input_func_native, mid_surf_native, DilateFactor, input_func_native, '-nearest' ]) ## Erin's new addition - find what is below a certain percentile and dilate.. ## Erin's new addition - find what is below a certain percentile and dilate.. if DilateBelowPct: DilThres = get_stdout([ 'wb_command', '-metric-stats', input_func_native, '-percentile', str(DilateBelowPct), '-column', str(MiddleTR), '-roi', roi_native_gii ]) lowvoxels_gii = os.path.join( tmpdir, '{}.lowvoxels.native.func.gii'.format(Hemisphere)) run([ 'wb_command', '-metric-math', '"(x < {})"'.format(DilThres), lowvoxels_gii, '-var', 'x', input_func_native, '-column', str(MiddleTR) ]) run([ 'wb_command', '-metric-dilate', input_func_native, mid_surf_native, str(DilateFactor), input_func_native, '-bad-vertex-roi', lowvoxels_gii, '-nearest' ]) ## back to the HCP program - do the mask and resample ## mask resample than mask combo input_func_32k = os.path.join( tmpdir, '{}.{}.atlasroi.{}k_fs_LR.func.gii'.format(NameOffMRI, Hemisphere, LowResMesh)) mask_and_resample(input_func_native, input_func_32k, roi_native_gii, roi_32k_gii, mid_surf_native, mid_surf_32k, sphere_reg_native, sphere_reg_32k) if OutputSurfDiagnostics: logger.info( section_header('Writing Surface Mapping Diagnotic Files')) for mapname in ["mean", "cov"]: if mapname == "mean": map_vol = tmean_vol if mapname == "cov": map_vol = cov_vol ## the output directories for this section map_native_gii = os.path.join( tmpdir, '{}.{}.native.func.gii'.format(mapname, Hemisphere)) map_32k_gii = os.path.join( tmpdir, "{}.{}.{}k_fs_LR.func.gii".format(Hemisphere, mapname, LowResMesh)) run([ 'wb_command', '-volume-to-surface-mapping', map_vol, mid_surf_native, map_native_gii, '-ribbon-constrained', white_surf, pial_surf, '-volume-roi', goodvoxels_vol ]) run([ 'wb_command', '-metric-dilate', map_native_gii, mid_surf_native, DilateFactor, map_native_gii, '-nearest' ]) mask_and_resample(map_native_gii, map_32k_gii, roi_native_gii, roi_32k_gii, mid_surf_native, mid_surf_32k, sphere_reg_native, sphere_reg_32k) mapall_native_gii = os.path.join( tmpdir, '{}_all.{}.native.func.gii'.format(mapname, Hemisphere)) mapall_32k_gii = os.path.join( tmpdir, "{}.{}_all.{}k_fs_LR.func.gii".format( Hemisphere, mapname, LowResMesh)) run([ 'wb_command', '-volume-to-surface-mapping', map_vol, mid_surf_native, mapall_native_gii, '-ribbon-constrained', white_surf, pial_surf ]) mask_and_resample(mapall_native_gii, mapall_32k_gii, roi_native_gii, roi_32k_gii, mid_surf_native, mid_surf_32k, sphere_reg_native, sphere_reg_32k) ## now project the goodvoxels to the surface goodvoxels_native_gii = os.path.join( tmpdir, '{}.goodvoxels.native.func.gii'.format(Hemisphere)) goodvoxels_32k_gii = os.path.join( tmpdir, '{}.goodvoxels.{}k_fs_LR.func.gii'.format( Hemisphere, LowResMesh)) run([ 'wb_command', '-volume-to-surface-mapping', goodvoxels_vol, mid_surf_native, goodvoxels_native_gii, '-ribbon-constrained', white_surf, pial_surf ]) mask_and_resample(goodvoxels_native_gii, goodvoxels_32k_gii, roi_native_gii, roi_32k_gii, mid_surf_native, mid_surf_32k, sphere_reg_native, sphere_reg_32k) ## Also ouput the resampled low voxels if DilateBelowPct: lowvoxels_32k_gii = os.path.join( tmpdir, '{}.lowvoxels.{}k_fs_LR.func.gii'.format( Hemisphere, LowResMesh)) mask_and_resample(lowvoxels_gii, lowvoxels_32k_gii, roi_native_gii, roi_32k_gii, mid_surf_native, mid_surf_32k, sphere_reg_native, sphere_reg_32k) if OutputSurfDiagnostics: Maps = ['goodvoxels', 'mean', 'mean_all', 'cov', 'cov_all'] if DilateBelowPct: Maps.append('lowvoxels') # import pbd; pdb.set_trace() for Map in Maps: run([ 'wb_command', '-cifti-create-dense-scalar', os.path.join( DiagnosticsFolder, '{}.atlasroi.{}k_fs_LR.dscalar.nii'.format( Map, LowResMesh)), '-left-metric', os.path.join(tmpdir, 'L.{}.{}k_fs_LR.func.gii'.format(Map, LowResMesh)), '-roi-left', os.path.join( DownSampleFolder, '{}.L.atlasroi.{}k_fs_LR.shape.gii'.format( Subject, LowResMesh)), '-right-metric', os.path.join(tmpdir, 'R.{}.{}k_fs_LR.func.gii'.format(Map, LowResMesh)), '-roi-right', os.path.join( DownSampleFolder, '{}.R.atlasroi.{}k_fs_LR.shape.gii'.format( Subject, LowResMesh)) ]) ############ The subcortical resampling step... logger.info(section_header("Subcortical Processing")) logger.info("VolumefMRI: {}".format(input_fMRI_4D)) Atlas_Subcortical = os.path.join( tmpdir, '{}_AtlasSubcortical_s0.nii.gz'.format(NameOffMRI)) AtlasROIvols = os.path.join( AtlasSpaceFolder, "ROIs", 'Atlas_ROIs.{}.nii.gz'.format(GrayordinatesResolution)) atlas_roi_vol = subcortical_atlas(input_fMRI_4D, AtlasSpaceFolder, ResultsFolder, GrayordinatesResolution, tmpdir) resample_subcortical(input_fMRI_4D, atlas_roi_vol, AtlasROIvols, Atlas_Subcortical, tmpdir) #Generation of Dense Timeseries logger.info(section_header("Generation of Dense Timeseries")) cifti_output_s0 = os.path.join( ResultsFolder, '{}_Atlas_s0.dtseries.nii'.format(NameOffMRI)) run([ 'wb_command', '-cifti-create-dense-timeseries', cifti_output_s0, '-volume', Atlas_Subcortical, AtlasROIvols, '-left-metric', os.path.join( tmpdir, '{}.L.atlasroi.{}k_fs_LR.func.gii'.format(NameOffMRI, LowResMesh)), '-roi-left', os.path.join( DownSampleFolder, '{}.L.atlasroi.{}k_fs_LR.shape.gii'.format(Subject, LowResMesh)), '-right-metric', os.path.join( tmpdir, '{}.R.atlasroi.{}k_fs_LR.func.gii'.format(NameOffMRI, LowResMesh)), '-roi-right', os.path.join( DownSampleFolder, '{}.R.atlasroi.{}k_fs_LR.shape.gii'.format(Subject, LowResMesh)), '-timestep', TR_vol ]) #########cifti smoothing ################ if SmoothingFWHM: logger.info(section_header("Smoothing Output")) Sigma = FWHM2Sigma(SmoothingFWHM) logger.info("FWHM: {}".format(SmoothingFWHM)) logger.info("Sigma: {}".format(Sigma)) run([ 'wb_command', '-cifti-smoothing', cifti_output_s0, str(Sigma), str(Sigma), 'COLUMN', os.path.join( ResultsFolder, '{}_Atlas_s{}.dtseries.nii'.format(NameOffMRI, SmoothingFWHM)), '-left-surface', os.path.join( DownSampleFolder, '{}.L.midthickness.{}k_fs_LR.surf.gii'.format( Subject, LowResMesh)), '-right-surface', os.path.join( DownSampleFolder, '{}.R.midthickness.{}k_fs_LR.surf.gii'.format( Subject, LowResMesh)) ])
def run_ciftify_subject_fmri(settings, tmpdir): ## write a bunch of info about the environment to the logs log_build_environment() ## print the settings to the logs settings.print_settings() # define some mesh paths as a dictionary meshes = define_meshes(settings.subject.path, tmpdir, low_res_meshes = settings.low_res) logger.info('The functional data will first be projected to ' 'the surfaces in {}'.format(meshes['AtlasSpaceNative']['Folder'])) logger.info('The data is then resampled to the {} surfaces in {} folder using the {} sphere'.format( meshes['AtlasSpaceNative']['meshname'], meshes['AtlasSpaceNative']['Folder'], settings.surf_reg)) if not settings.diagnostics.path: settings.diagnostics.path = tmpdir else: logger.info('cifti files for surface mapping QA will' ' be written to {}:'.format(settings.diagnostics.path)) ## either transform or copy the input_fMRI native_func_3D = define_func_3D(settings, tmpdir) if settings.already_atlas_transformed: atlas_fMRI_4D, atlas_fMRI_3D = copy_atlas_images(settings) else: logger.info(section_header('MNI Transform')) if not settings.run_flirt: func2T1w_mat = calc_sform_differences(native_func_3D, settings, tmpdir) else: func2T1w_mat = run_flirt_to_T1w(native_func_3D, settings) atlas_fMRI_4D, atlas_fMRI_3D = transform_to_MNI(func2T1w_mat, native_func_3D, settings) #Make fMRI Ribbon #Noisy Voxel Outlier Exclusion #Ribbon-based Volume to Surface mapping and resampling to standard surface logger.info(section_header('Making fMRI Ribbon')) ribbon_vol=os.path.join(settings.diagnostics.path,'ribbon_only.nii.gz') make_cortical_ribbon(ref_vol = atlas_fMRI_3D, ribbon_vol = ribbon_vol, settings = settings, mesh_settings = meshes['AtlasSpaceNative']) logger.info(section_header('Determining Noisy fMRI voxels')) goodvoxels_vol = os.path.join(settings.diagnostics.path, 'goodvoxels.nii.gz') tmean_vol, cov_vol = define_good_voxels( atlas_fMRI_4D, ribbon_vol, goodvoxels_vol, tmpdir) logger.info(section_header('Mapping fMRI to 32k Surface')) # create the tempdirs that will hold intermediate surface files for mesh in meshes.values(): ciftify.utils.make_dir(mesh['tmpdir'], DRYRUN) for Hemisphere in ["L", "R"]: ## now finally, actually project the fMRI input map_volume_to_surface(vol_input = atlas_fMRI_4D, map_name = settings.fmri_label, subject = settings.subject.id, hemisphere = Hemisphere, mesh_settings = meshes['AtlasSpaceNative'], dilate_factor = settings.dilate_factor, volume_roi = goodvoxels_vol) ## Erin's new addition - find what is below a certain percentile and dilate.. if settings.dilate_percent_below: dilate_out_low_intensity_voxels(settings, Hemisphere, meshes['AtlasSpaceNative']) ## back to the HCP program - do the mask and resample for low_res_mesh in settings.low_res: mask_and_resample(map_name = settings.fmri_label, subject = settings.subject.id, hemisphere = Hemisphere, src_mesh = meshes['AtlasSpaceNative'], dest_mesh = meshes['{}k_fs_LR'.format(low_res_mesh)], surf_reg_name = settings.surf_reg) if settings.diagnostics.requested: build_diagnositic_cifti_files(tmean_vol, cov_vol, goodvoxels_vol, settings, meshes) ############ The subcortical resampling step... logger.info(section_header("Subcortical Processing")) logger.info("VolumefMRI: {}".format(atlas_fMRI_4D)) atlas_roi_vol_greyord_res = os.path.join(settings.subject.atlas_space_dir, "ROIs",'Atlas_ROIs.{}.nii.gz'.format(settings.grayord_res)) atlas_roi_vol_fmri_res = subcortical_atlas(atlas_fMRI_4D, settings.subject.atlas_space_dir, settings.results_dir, settings.grayord_res, tmpdir) tmp_dilate_cifti, tmp_roi_dlabel = resample_subcortical_part1( input_fMRI = atlas_fMRI_4D, atlas_roi_vol_fmri_res = atlas_roi_vol_fmri_res, atlas_roi_vol_greyord_res = atlas_roi_vol_greyord_res, tmpdir = tmpdir) subcortical_data_s0 = resample_subcortical_part2( tmp_dilate_cifti, tmp_roi_dlabel, run_smoothing = False, settings = settings, tmpdir = tmpdir) #Generation of Dense Timeseries logger.info(section_header("Generation of Dense Timeseries")) for low_res_mesh in settings.low_res: create_dense_timeseries(map_name = settings.fmri_label, smoothing_fwhm = '0', settings = settings, subcortical_data = subcortical_data_s0, subcortical_labels = atlas_roi_vol_greyord_res, mesh_settings = meshes['{}k_fs_LR'.format(low_res_mesh)]) #########cifti smoothing ################ if settings.smoothing.sigma > 0: logger.info(section_header("Smoothing Output")) logger.info("FWHM: {}".format(settings.smoothing.fwhm)) logger.info("Sigma: {}".format(settings.smoothing.sigma)) subcortical_data_sm = resample_subcortical_part2( tmp_dilate_cifti, tmp_roi_dlabel, run_smoothing = True, settings = settings, tmpdir = tmpdir) for low_res_mesh in settings.low_res: for Hemisphere in ['L', 'R']: metric_smoothing(Hemisphere, settings, mesh_settings = meshes['{}k_fs_LR'.format(low_res_mesh)]) create_dense_timeseries( map_name = settings.fmri_label, smoothing_fwhm = settings.smoothing.fwhm, settings = settings, subcortical_data = subcortical_data_sm, subcortical_labels = atlas_roi_vol_greyord_res, mesh_settings = meshes['{}k_fs_LR'.format(low_res_mesh)])
def build_diagnositic_cifti_files(tmean_vol, cov_vol, goodvoxels_vol, settings, meshes): ''' projects a bunch of diagnostic volumes to the surface and resamples them to the low res meshes. Than it build dscalar.nii outputs ''' logger.info(section_header('Writing Surface Mapping Diagnotic Files')) for Hemisphere in ['L','R']: for map_name in ["mean", "cov"]: if map_name == "mean": map_vol = tmean_vol if map_name == "cov": map_vol = cov_vol ## project the maps of mean and cov signal with bad voxels removed volume_to_surface_plus_resampling( vol_input = map_vol, map_name = map_name, hemisphere = Hemisphere, settings = settings, meshes = meshes, volume_roi = goodvoxels_vol, dilate_factor = settings.dilate_factor) ## project the maps of mean and cov signal with bad voxels left in volume_to_surface_plus_resampling( vol_input = map_vol, map_name = "{}_all".format(map_name), hemisphere = Hemisphere, settings = settings, meshes = meshes, volume_roi = None, dilate_factor = None) ## project the maps of mean and cov signal with bad voxels left in volume_to_surface_plus_resampling( vol_input = goodvoxels_vol, map_name = "goodvoxels", hemisphere = Hemisphere, settings = settings, meshes = meshes, volume_roi = None, dilate_factor = None) ## Also ouput the resampled low voxels if settings.dilate_percent_below: for low_res_mesh in settings.low_res: mask_and_resample(map_name = "lowvoxels", subject = settings.subject.id, hemisphere = Hemisphere, src_mesh = meshes['AtlasSpaceNative'], dest_mesh = meshes['{}k_fs_LR'.format(low_res_mesh)], surf_reg_name = settings.surf_reg) map_names = ['goodvoxels', 'mean', 'mean_all', 'cov', 'cov_all'] if settings.dilate_percent_below: map_names.append('lowvoxels') # import pbd; pdb.set_trace() for map_name in map_names: for low_res_mesh in settings.low_res: mesh_settings = meshes['{}k_fs_LR'.format(low_res_mesh)] run(['wb_command', '-cifti-create-dense-scalar', os.path.join(settings.diagnostics.path, '{}.atlasroi.{}.dscalar.nii'.format(map_name, mesh_settings['meshname'])), '-left-metric', func_gii_file(settings.subject.id, map_name, 'L', mesh_settings), '-roi-left', medial_wall_roi_file(settings.subject.id, 'L', mesh_settings), '-right-metric', func_gii_file(settings.subject.id, map_name, 'R', mesh_settings), '-roi-right', medial_wall_roi_file(settings.subject.id, 'R', mesh_settings)])