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)])
