def create_activation_pics(sbref_brain, thresh_zstat1, thresh_zstat2, thresh_zfstat1): import nipype.interfaces.fsl as fsl Overlay_t1_Contrast = fsl.Overlay() Overlay_t1_Contrast.inputs.background_image = sbref_brain Overlay_t1_Contrast.inputs.stat_image = thresh_zstat1 Overlay_t1_Contrast.inputs.auto_thresh_bg = True Overlay_t1_Contrast.inputs.stat_thresh = (2.300302, 12) Overlay_t1_Contrast.inputs.transparency = True Overlay_t1_Contrast.inputs.out_file = 'rendered_thresh_zstat1.nii.gz' Overlay_t1_Contrast.run() Slicer_t1_Contrast = fsl.Slicer() Slicer_t1_Contrast.inputs.in_file = 'rendered_thresh_zstat1.nii.gz' Slicer_t1_Contrast.inputs.all_axial = True Slicer_t1_Contrast.inputs.image_width = 750 Slicer_t1_Contrast.inputs.out_file = 'rendered_thresh_zstat1.png' Slicer_t1_Contrast.run() #=============================================================================== Overlay_t2_Contrast = fsl.Overlay() Overlay_t2_Contrast.inputs.background_image = sbref_brain Overlay_t2_Contrast.inputs.stat_image = thresh_zstat1 Overlay_t2_Contrast.inputs.auto_thresh_bg = True Overlay_t2_Contrast.inputs.stat_thresh = (2.300302, 12) Overlay_t2_Contrast.inputs.transparency = True Overlay_t2_Contrast.inputs.out_file = 'rendered_thresh_zstat2.nii.gz' Overlay_t2_Contrast.run() Slicer_t2_Contrast = fsl.Slicer() Slicer_t2_Contrast.inputs.in_file = 'rendered_thresh_zstat2.nii.gz' Slicer_t2_Contrast.inputs.all_axial = True Slicer_t2_Contrast.inputs.image_width = 750 Slicer_t2_Contrast.inputs.out_file = 'rendered_thresh_zstat2.png' Slicer_t2_Contrast.run() #=============================================================================== Overlay_f_Contrast = fsl.Overlay() Overlay_f_Contrast.inputs.background_image = sbref_brain Overlay_f_Contrast.inputs.stat_image = thresh_zstat1 Overlay_f_Contrast.inputs.auto_thresh_bg = True Overlay_f_Contrast.inputs.stat_thresh = (2.300302, 12) Overlay_f_Contrast.inputs.transparency = True Overlay_f_Contrast.inputs.out_file = 'rendered_thresh_zfstat1.nii.gz' Overlay_f_Contrast.run() Slicer_f_Contrast = fsl.Slicer() Slicer_f_Contrast.inputs.in_file = 'rendered_thresh_zfstat1.nii.gz' Slicer_f_Contrast.inputs.all_axial = True Slicer_f_Contrast.inputs.image_width = 750 Slicer_f_Contrast.inputs.out_file = 'rendered_thresh_zfstat1.png' Slicer_f_Contrast.run()
def create_overlay_workflow(name='overlay'): """Setup overlay workflow """ overlay = pe.Workflow(name='overlay') overlaystats = pe.MapNode(interface=fsl.Overlay(), name="overlaystats", iterfield=['stat_image']) overlaystats.inputs.show_negative_stats = True overlaystats.inputs.auto_thresh_bg = True slicestats = pe.MapNode(interface=fsl.Slicer(), name="slicestats", iterfield=['in_file']) slicestats.inputs.all_axial = True slicestats.inputs.image_width = 512 overlay.connect(overlaystats, 'out_file', slicestats, 'in_file') return overlay
level1estimate.inputs.estimation_method = {'Classical': 1} """Use :class:`nipype.interfaces.spm.EstimateContrast` to estimate the first level contrasts specified in a few steps above. """ contrastestimate = pe.Node(spm.EstimateContrast(), name="contrastestimate") """Use :class: `nipype.interfaces.utility.Select` to select each contrast for reporting. """ selectcontrast = pe.Node(niu.Select(), name="selectcontrast") """Use :class:`nipype.interfaces.fsl.Overlay` to combine the statistical output of the contrast estimate and a background image into one volume. """ overlaystats = pe.Node(fsl.Overlay(), name="overlaystats") overlaystats.inputs.stat_thresh = (3, 10) overlaystats.inputs.show_negative_stats = True overlaystats.inputs.auto_thresh_bg = True """Use :class:`nipype.interfaces.fsl.Slicer` to create images of the overlaid statistical volumes for a report of the first-level results. """ slicestats = pe.Node(fsl.Slicer(), name="slicestats") slicestats.inputs.all_axial = True slicestats.inputs.image_width = 750 l1analysis.connect([ (modelspec, level1design, [('session_info', 'session_info')]), (level1design, level1estimate, [('spm_mat_file', 'spm_mat_file')]), (level1estimate, contrastestimate, [('spm_mat_file', 'spm_mat_file'),
"""Use :class:`nipype.interfaces.spm.EstimateContrast` to estimate the first level contrasts specified in a few steps above. """ contrastestimate = pe.Node(interface=spm.EstimateContrast(), name="contrastestimate") """Use :class: `nipype.interfaces.utility.Select` to select each contrast for reporting. """ selectcontrast = pe.Node(interface=util.Select(), name="selectcontrast") """Use :class:`nipype.interfaces.fsl.Overlay` to combine the statistical output of the contrast estimate and a background image into one volume. """ overlaystats = pe.Node(interface=fsl.Overlay(), name="overlaystats") overlaystats.inputs.stat_thresh = (3, 10) overlaystats.inputs.show_negative_stats = True overlaystats.inputs.auto_thresh_bg = True """Use :class:`nipype.interfaces.fsl.Slicer` to create images of the overlaid statistical volumes for a report of the first-level results. """ slicestats = pe.Node(interface=fsl.Slicer(), name="slicestats") slicestats.inputs.all_axial = True slicestats.inputs.image_width = 750 l1analysis.connect([ (modelspec, level1design, [('session_info', 'session_info')]), (level1design, level1estimate, [('spm_mat_file', 'spm_mat_file')]), (level1estimate, contrastestimate, [('spm_mat_file', 'spm_mat_file'),
# Clustering_t.inputs.out_localmax_txt_file = 'localmax' #----------------------------------------------------------------------------------------------------- # In[15]: #Clusterin on the statistical output of f-contrast Clustering_f = Node(fsl.Cluster(), name = 'Clustering_f_Contrast') Clustering_f.inputs.threshold = 2.3 Clustering_f.inputs.pthreshold = 0.05 Clustering_f.inputs.out_threshold_file = 'thresh_zfstat1.nii.gz' #----------------------------------------------------------------------------------------------------- # In[15]: #Overlay t contrast Overlay_t_Contrast = Node(fsl.Overlay(), name = 'Overlay_t_Contrast') Overlay_t_Contrast.inputs.auto_thresh_bg = True Overlay_t_Contrast.inputs.stat_thresh = (2.300302,4.877862) Overlay_t_Contrast.inputs.transparency = True #----------------------------------------------------------------------------------------------------- # In[15]: #Overlay f contrast Overlay_f_Contrast = Node(fsl.Overlay(), name = 'Overlay_f_Contrast') Overlay_f_Contrast.inputs.auto_thresh_bg = True Overlay_f_Contrast.inputs.stat_thresh = (2.300302,4.877862) Overlay_f_Contrast.inputs.transparency = True #-----------------------------------------------------------------------------------------------------
def easy_thresh(wf_name): """ Workflow for carrying out cluster-based thresholding and colour activation overlaying Parameters ---------- wf_name : string Workflow name Returns ------- easy_thresh : object Easy thresh workflow object Notes ----- `Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/easy_thresh/easy_thresh.py>`_ Workflow Inputs:: inputspec.z_stats : string (nifti file) z_score stats output for t or f contrast from flameo inputspec.merge_mask : string (nifti file) mask generated from 4D Merged derivative file inputspec.z_threshold : float Z Statistic threshold value for cluster thresholding. It is used to determine what level of activation would be statistically significant. Increasing this will result in higher estimates of required effect. inputspec.p_threshold : float Probability threshold for cluster thresholding. inputspec.paramerters : string (tuple) tuple containing which MNI and FSLDIR path information Workflow Outputs:: outputspec.cluster_threshold : string (nifti files) the thresholded Z statistic image for each t contrast outputspec.cluster_index : string (nifti files) image of clusters for each t contrast; the values in the clusters are the index numbers as used in the cluster list. outputspec.overlay_threshold : string (nifti files) 3D color rendered stats overlay image for t contrast After reloading this image, use the Statistics Color Rendering GUI to reload the color look-up-table outputspec.overlay_rendered_image : string (nifti files) 2D color rendered stats overlay picture for each t contrast outputspec.cluster_localmax_txt : string (text files) local maxima text file, defines the coordinates of maximum value in the cluster Order of commands: - Estimate smoothness of the image:: smoothest --mask= merge_mask.nii.gz --zstat=.../flameo/stats/zstat1.nii.gz arguments --mask : brain mask volume --zstat : filename of zstat/zfstat image - Create mask. For details see `fslmaths <http://www.fmrib.ox.ac.uk/fslcourse/lectures/practicals/intro/index.htm#fslutils>`_:: fslmaths ../flameo/stats/zstat1.nii.gz -mas merge_mask.nii.gz zstat1_mask.nii.gz arguments -mas : use (following image>0) to mask current image - Copy Geometry image dimensions, voxel dimensions, voxel dimensions units string, image orientation/origin or qform/sform info) from one image to another:: fslcpgeom MNI152_T1_2mm_brain.nii.gz zstat1_mask.nii.gz - Cluster based thresholding. For details see `FEAT <http://www.fmrib.ox.ac.uk/fsl/feat5/detail.html#poststats>`_:: cluster --dlh = 0.0023683100 --in = zstat1_mask.nii.gz --oindex = zstat1_cluster_index.nii.gz --olmax = zstat1_cluster_localmax.txt --othresh = zstat1_cluster_threshold.nii.gz --pthresh = 0.0500000000 --thresh = 2.3000000000 --volume = 197071 arguments --in : filename of input volume --dlh : smoothness estimate = sqrt(det(Lambda)) --oindex : filename for output of cluster index --othresh : filename for output of thresholded image --olmax : filename for output of local maxima text file --volume : number of voxels in the mask --pthresh : p-threshold for clusters --thresh : threshold for input volume Z statistic image is thresholded to show which voxels or clusters of voxels are activated at a particular significance level. A Z statistic threshold is used to define contiguous clusters. Then each cluster's estimated significance level (from GRF-theory) is compared with the cluster probability threshold. Significant clusters are then used to mask the original Z statistic image. - Get the maximum intensity value of the output thresholded image. This used is while rendering the Z statistic image:: fslstats zstat1_cluster_threshold.nii.gz -R arguments -R : output <min intensity> <max intensity> - Rendering. For details see `FEAT <http://www.fmrib.ox.ac.uk/fsl/feat5/detail.html#poststats>`_:: overlay 1 0 MNI152_T1_2mm_brain.nii.gz -a zstat1_cluster_threshold.nii.gz 2.30 15.67 zstat1_cluster_threshold_overlay.nii.gz slicer zstat1_cluster_threshold_overlay.nii.gz -L -A 750 zstat1_cluster_threshold_overlay.png The Z statistic range selected for rendering is automatically calculated by default, to run from red (minimum Z statistic after thresholding) to yellow (maximum Z statistic, here maximum intensity). High Level Workflow Graph: .. image:: ../images/easy_thresh.dot.png :width: 800 Detailed Workflow Graph: .. image:: ../images/easy_thresh_detailed.dot.png :width: 800 Examples -------- >>> import easy_thresh >>> preproc = easy_thresh.easy_thresh("new_workflow") >>> preproc.inputs.inputspec.z_stats= 'flameo/stats/zstat1.nii.gz' >>> preproc.inputs.inputspec.merge_mask = 'merge_mask/alff_Z_fn2standard_merged_mask.nii.gz' >>> preproc.inputs.inputspec.z_threshold = 2.3 >>> preproc.inputs.inputspec.p_threshold = 0.05 >>> preproc.inputs.inputspec.parameters = ('/usr/local/fsl/', 'MNI152') >>> preporc.run() -- SKIP doctest """ easy_thresh = pe.Workflow(name=wf_name) inputnode = pe.Node(util.IdentityInterface(fields=[ 'z_stats', 'merge_mask', 'z_threshold', 'p_threshold', 'parameters' ]), name='inputspec') outputnode = pe.Node(util.IdentityInterface(fields=[ 'cluster_threshold', 'cluster_index', 'cluster_localmax_txt', 'overlay_threshold', 'rendered_image' ]), name='outputspec') ### fsl easythresh # estimate image smoothness smooth_estimate = pe.MapNode(interface=fsl.SmoothEstimate(), name='smooth_estimate', iterfield=['zstat_file']) # run clustering after fixing stats header for talspace zstat_mask = pe.MapNode(interface=fsl.MultiImageMaths(), name='zstat_mask', iterfield=['in_file']) #operations to perform #-mas use (following image>0) to mask current image zstat_mask.inputs.op_string = '-mas %s' #fslcpgeom #copy certain parts of the header information (image dimensions, #voxel dimensions, voxel dimensions units string, image orientation/origin #or qform/sform info) from one image to another copy_geometry = pe.MapNode(util.Function( input_names=['infile_a', 'infile_b'], output_names=['out_file'], function=copy_geom), name='copy_geometry', iterfield=['infile_a', 'infile_b']) ##cluster-based thresholding #After carrying out the initial statistical test, the resulting #Z statistic image is then normally thresholded to show which voxels or #clusters of voxels are activated at a particular significance level. #A Z statistic threshold is used to define contiguous clusters. #Then each cluster's estimated significance level (from GRF-theory) is #compared with the cluster probability threshold. Significant clusters #are then used to mask the original Z statistic image for later production #of colour blobs.This method of thresholding is an alternative to #Voxel-based correction, and is normally more sensitive to activation. # cluster = pe.MapNode(interface=fsl.Cluster(), # name='cluster', # iterfield=['in_file', 'volume', 'dlh']) # #output of cluster index (in size order) # cluster.inputs.out_index_file = True # #thresholded image # cluster.inputs.out_threshold_file = True # #local maxima text file # #defines the cluster cordinates # cluster.inputs.out_localmax_txt_file = True cluster = pe.MapNode(util.Function( input_names=[ 'in_file', 'volume', 'dlh', 'threshold', 'pthreshold', 'parameters' ], output_names=['index_file', 'threshold_file', 'localmax_txt_file'], function=call_cluster), name='cluster', iterfield=['in_file', 'volume', 'dlh']) #max and minimum intensity values image_stats = pe.MapNode(interface=fsl.ImageStats(), name='image_stats', iterfield=['in_file']) image_stats.inputs.op_string = '-R' #create tuple of z_threshold and max intensity value of threshold file create_tuple = pe.MapNode(util.Function( input_names=['infile_a', 'infile_b'], output_names=['out_file'], function=get_tuple), name='create_tuple', iterfield=['infile_b']) #colour activation overlaying overlay = pe.MapNode(interface=fsl.Overlay(), name='overlay', iterfield=['stat_image', 'stat_thresh']) overlay.inputs.transparency = True overlay.inputs.auto_thresh_bg = True overlay.inputs.out_type = 'float' #colour rendering slicer = pe.MapNode(interface=fsl.Slicer(), name='slicer', iterfield=['in_file']) #set max picture width slicer.inputs.image_width = 750 # set output all axial slices into one picture slicer.inputs.all_axial = True #function mapnode to get the standard fsl brain image #based on parameters as FSLDIR,MNI and voxel size get_backgroundimage = pe.MapNode(util.Function( input_names=['in_file', 'file_parameters'], output_names=['out_file'], function=get_standard_background_img), name='get_bckgrndimg1', iterfield=['in_file']) #function node to get the standard fsl brain image #outputs single file get_backgroundimage2 = pe.Node(util.Function( input_names=['in_file', 'file_parameters'], output_names=['out_file'], function=get_standard_background_img), name='get_backgrndimg2') #connections easy_thresh.connect(inputnode, 'z_stats', smooth_estimate, 'zstat_file') easy_thresh.connect(inputnode, 'merge_mask', smooth_estimate, 'mask_file') easy_thresh.connect(inputnode, 'z_stats', zstat_mask, 'in_file') easy_thresh.connect(inputnode, 'merge_mask', zstat_mask, 'operand_files') easy_thresh.connect(zstat_mask, 'out_file', get_backgroundimage, 'in_file') easy_thresh.connect(inputnode, 'parameters', get_backgroundimage, 'file_parameters') easy_thresh.connect(get_backgroundimage, 'out_file', copy_geometry, 'infile_a') easy_thresh.connect(zstat_mask, 'out_file', copy_geometry, 'infile_b') easy_thresh.connect(copy_geometry, 'out_file', cluster, 'in_file') easy_thresh.connect(inputnode, 'z_threshold', cluster, 'threshold') easy_thresh.connect(inputnode, 'p_threshold', cluster, 'pthreshold') easy_thresh.connect(smooth_estimate, 'volume', cluster, 'volume') easy_thresh.connect(smooth_estimate, 'dlh', cluster, 'dlh') easy_thresh.connect(inputnode, 'parameters', cluster, 'parameters') easy_thresh.connect(cluster, 'threshold_file', image_stats, 'in_file') easy_thresh.connect(image_stats, 'out_stat', create_tuple, 'infile_b') easy_thresh.connect(inputnode, 'z_threshold', create_tuple, 'infile_a') easy_thresh.connect(cluster, 'threshold_file', overlay, 'stat_image') easy_thresh.connect(create_tuple, 'out_file', overlay, 'stat_thresh') easy_thresh.connect(inputnode, 'merge_mask', get_backgroundimage2, 'in_file') easy_thresh.connect(inputnode, 'parameters', get_backgroundimage2, 'file_parameters') easy_thresh.connect(get_backgroundimage2, 'out_file', overlay, 'background_image') easy_thresh.connect(overlay, 'out_file', slicer, 'in_file') easy_thresh.connect(cluster, 'threshold_file', outputnode, 'cluster_threshold') easy_thresh.connect(cluster, 'index_file', outputnode, 'cluster_index') easy_thresh.connect(cluster, 'localmax_txt_file', outputnode, 'cluster_localmax_txt') easy_thresh.connect(overlay, 'out_file', outputnode, 'overlay_threshold') easy_thresh.connect(slicer, 'out_file', outputnode, 'rendered_image') return easy_thresh
#cluster copes1 cluster_copes1 = Node(fsl.model.Cluster(), name='cluster_copes1') cluster_copes1.inputs.threshold = 2.3 cluster_copes1.inputs.pthreshold = 0.05 cluster_copes1.inputs.connectivity = 26 cluster_copes1.inputs.out_threshold_file = 'thresh_zstat1.nii.gz' cluster_copes1.inputs.out_index_file = 'cluster_mask_zstat1' cluster_copes1.inputs.out_localmax_txt_file = 'lmax_zstat1_std.txt' cluster_copes1.inputs.use_mm = True #========================================================================================================================================================== #overlay thresh_zstat1 overlay_cope1 = Node(fsl.Overlay(), name='overlay_cope1') overlay_cope1.inputs.auto_thresh_bg = True overlay_cope1.inputs.stat_thresh = (2.300302, 14) overlay_cope1.inputs.transparency = True overlay_cope1.inputs.out_file = 'rendered_thresh_zstat1.nii.gz' overlay_cope1.inputs.show_negative_stats = True #========================================================================================================================================================== #generate pics thresh_zstat1 slicer_cope1 = Node(fsl.Slicer(), name='slicer_cope1') slicer_cope1.inputs.sample_axial = 2 slicer_cope1.inputs.image_width = 2000 slicer_cope1.inputs.out_file = 'rendered_thresh_zstat1.png' #===========================================================================================================================================================
cluster_zstats = Node(name='cluster_zstats', interface=Function( input_names=['zstat', 'volume', 'dlh'], output_names=['threshold_file'], function=cluster_zstats)) #========================================================================================================================================================= #threshold the maps to 3.1 to make it ready for submission apply_thresh = Node(fsl.Threshold(), name='apply_threshold_3_1') apply_thresh.inputs.thresh = 3.1 apply_thresh.inputs.out_file = 'threshold_file.nii.gz' #========================================================================================================================================================== #overlay thresh_zstat1 overlay_zstat = Node(fsl.Overlay(), name='overlay') overlay_zstat.inputs.auto_thresh_bg = True overlay_zstat.inputs.stat_thresh = (3.1, 10) overlay_zstat.inputs.transparency = True overlay_zstat.inputs.out_file = 'rendered_thresh_zstat.nii.gz' overlay_zstat.inputs.show_negative_stats = True overlay_zstat.inputs.background_image = template_brain #========================================================================================================================================================== #generate pics thresh_zstat1 slicer_zstat = Node(fsl.Slicer(), name='slicer') slicer_zstat.inputs.sample_axial = 2 slicer_zstat.inputs.image_width = 2000 slicer_zstat.inputs.out_file = 'rendered_thresh_zstat.png'
mask_zstat = Node(fsl.ApplyMask(), name='mask_zstat') mask_zstat.inputs.out_file = 'thresh_zstat.nii.gz' # ============================================================================================================================ clustering_t = Node(fsl.Cluster(), name='clustering_t_contrast') clustering_t.inputs.threshold = 2.3 clustering_t.inputs.pthreshold = 0.05 clustering_t.inputs.out_threshold_file = 'thresh_zstat.nii.gz' clustering_t.inputs.out_index_file = 'cluster_mask_zstat' clustering_t.inputs.out_localmax_txt_file = 'lmax_zstat.txt' clustering_t.inputs.connectivity = 26 # ============================================================================================================================ # In[15]: # overlay t contrast overlay_t_contrast = Node(fsl.Overlay(), name='overlay_t_contrast') overlay_t_contrast.inputs.auto_thresh_bg = True overlay_t_contrast.inputs.stat_thresh = (2.300302, 5) overlay_t_contrast.inputs.transparency = True # ============================================================================================================================ # In[15]: # slicer slicer_t_contrast = Node(fsl.Slicer(), name='generate_t_contrast_image') slicer_t_contrast.inputs.all_axial = True slicer_t_contrast.inputs.image_width = 500 # ============================================================================================================================ # |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| # |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| # ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
def create_confound_removal_workflow(workflow_name="confound_removal"): inputnode = pe.Node(util.IdentityInterface( fields=["subject_id", "timeseries", "reg_file", "motion_parameters"]), name="inputs") # Get the Freesurfer aseg volume from the Subjects Directory getaseg = pe.Node(io.FreeSurferSource(subjects_dir=fs.Info.subjectsdir()), name="getaseg") # Binarize the Aseg to use as a whole brain mask asegmask = pe.Node(fs.Binarize(min=0.5, dilate=2), name="asegmask") # Extract and erode a mask of the deep cerebral white matter extractwm = pe.Node(fs.Binarize(match=[2, 41], erode=3), name="extractwm") # Extract and erode a mask of the ventricles and CSF extractcsf = pe.Node(fs.Binarize(match=[4, 5, 14, 15, 24, 31, 43, 44, 63], erode=1), name="extractcsf") # Mean the timeseries across the fourth dimension meanfunc = pe.MapNode(fsl.MeanImage(), iterfield=["in_file"], name="meanfunc") # Invert the anatomical coregistration and resample the masks regwm = pe.MapNode(fs.ApplyVolTransform(inverse=True, interp="nearest"), iterfield=["source_file", "reg_file"], name="regwm") regcsf = pe.MapNode(fs.ApplyVolTransform(inverse=True, interp="nearest"), iterfield=["source_file", "reg_file"], name="regcsf") regbrain = pe.MapNode(fs.ApplyVolTransform(inverse=True, interp="nearest"), iterfield=["source_file", "reg_file"], name="regbrain") # Convert to Nifti for FSL tools convertwm = pe.MapNode(fs.MRIConvert(out_type="niigz"), iterfield=["in_file"], name="convertwm") convertcsf = pe.MapNode(fs.MRIConvert(out_type="niigz"), iterfield=["in_file"], name="convertcsf") convertbrain = pe.MapNode(fs.MRIConvert(out_type="niigz"), iterfield=["in_file"], name="convertbrain") # Add the mask images together for a report image addconfmasks = pe.MapNode(fsl.ImageMaths(suffix="conf", op_string="-mul 2 -add", out_data_type="char"), iterfield=["in_file", "in_file2"], name="addconfmasks") # Overlay and slice the confound mask overlaied on mean func for reporting confoverlay = pe.MapNode(fsl.Overlay(auto_thresh_bg=True, stat_thresh=(.7, 2)), iterfield=["background_image", "stat_image"], name="confoverlay") confslice = pe.MapNode(fsl.Slicer(image_width=800, label_slices=False), iterfield=["in_file"], name="confslice") confslice.inputs.sample_axial = 2 # Extract the mean signal from white matter and CSF masks wmtcourse = pe.MapNode(fs.SegStats(exclude_id=0, avgwf_txt_file=True), iterfield=["segmentation_file", "in_file"], name="wmtcourse") csftcourse = pe.MapNode(fs.SegStats(exclude_id=0, avgwf_txt_file=True), iterfield=["segmentation_file", "in_file"], name="csftcourse") # Extract the mean signal from over the whole brain globaltcourse = pe.MapNode(fs.SegStats(exclude_id=0, avgwf_txt_file=True), iterfield=["segmentation_file", "in_file"], name="globaltcourse") # Build the confound design matrix conf_inputs = [ "motion_params", "global_waveform", "wm_waveform", "csf_waveform" ] confmatrix = pe.MapNode(util.Function(input_names=conf_inputs, output_names=["confound_matrix"], function=make_confound_matrix), iterfield=conf_inputs, name="confmatrix") # Regress the confounds out of the timeseries confregress = pe.MapNode(fsl.FilterRegressor(filter_all=True), iterfield=["in_file", "design_file", "mask"], name="confregress") # Rename the confound mask png renamepng = pe.MapNode(util.Rename(format_string="confound_sources.png"), iterfield=["in_file"], name="renamepng") # Define the outputs outputnode = pe.Node( util.IdentityInterface(fields=["timeseries", "confound_sources"]), name="outputs") # Define and connect the confound workflow confound = pe.Workflow(name=workflow_name) confound.connect([ (inputnode, meanfunc, [("timeseries", "in_file")]), (inputnode, getaseg, [("subject_id", "subject_id")]), (getaseg, extractwm, [("aseg", "in_file")]), (getaseg, extractcsf, [("aseg", "in_file")]), (getaseg, asegmask, [("aseg", "in_file")]), (extractwm, regwm, [("binary_file", "target_file")]), (extractcsf, regcsf, [("binary_file", "target_file")]), (asegmask, regbrain, [("binary_file", "target_file")]), (meanfunc, regwm, [("out_file", "source_file")]), (meanfunc, regcsf, [("out_file", "source_file")]), (meanfunc, regbrain, [("out_file", "source_file")]), (inputnode, regwm, [("reg_file", "reg_file")]), (inputnode, regcsf, [("reg_file", "reg_file")]), (inputnode, regbrain, [("reg_file", "reg_file")]), (regwm, convertwm, [("transformed_file", "in_file")]), (regcsf, convertcsf, [("transformed_file", "in_file")]), (regbrain, convertbrain, [("transformed_file", "in_file")]), (convertwm, addconfmasks, [("out_file", "in_file")]), (convertcsf, addconfmasks, [("out_file", "in_file2")]), (addconfmasks, confoverlay, [("out_file", "stat_image")]), (meanfunc, confoverlay, [("out_file", "background_image")]), (confoverlay, confslice, [("out_file", "in_file")]), (confslice, renamepng, [("out_file", "in_file")]), (regwm, wmtcourse, [("transformed_file", "segmentation_file")]), (inputnode, wmtcourse, [("timeseries", "in_file")]), (regcsf, csftcourse, [("transformed_file", "segmentation_file")]), (inputnode, csftcourse, [("timeseries", "in_file")]), (regbrain, globaltcourse, [("transformed_file", "segmentation_file")]), (inputnode, globaltcourse, [("timeseries", "in_file")]), (inputnode, confmatrix, [("motion_parameters", "motion_params")]), (wmtcourse, confmatrix, [("avgwf_txt_file", "wm_waveform")]), (csftcourse, confmatrix, [("avgwf_txt_file", "csf_waveform")]), (globaltcourse, confmatrix, [("avgwf_txt_file", "global_waveform")]), (confmatrix, confregress, [("confound_matrix", "design_file")]), (inputnode, confregress, [("timeseries", "in_file")]), (convertbrain, confregress, [("out_file", "mask")]), (confregress, outputnode, [("out_file", "timeseries")]), (renamepng, outputnode, [("out_file", "confound_sources")]), ]) return confound
extractb0 = pe.Node(fsl.ExtractROI(t_size=1, t_min=1), name = "extractb0") bet = pe.Node(fsl.BET(frac=0.1, mask=True), name="bet_func") bet2 = pe.Node(fsl.BET(frac=0.1), name="bet_struc") segment = pe.Node(fsl.FAST(out_basename='fast_'), name="fastSeg") flirting = pe.Node(fsl.FLIRT(cost_func='normmi', dof=7, searchr_x=[-180, 180], searchr_y=[-180, 180], searchr_z=[-180,180]), name="struc_2_func") applyxfm = pe.MapNode(fsl.ApplyXfm(apply_xfm = True), name="MaskEPI", iterfield=['in_file']) erosion = pe.MapNode(fsl.ErodeImage(), name="erode_masks", iterfield=['in_file']) regcheckoverlay = pe.Node(fsl.Overlay(auto_thresh_bg=True, stat_thresh=(100,500)), name='OverlayCoreg') regcheck = pe.Node(fsl.Slicer(), name='CheckCoreg') #filterfeeder = pe.MapNode(fsl.ImageMeants(eig=True, )) datasink = pe.Node(nio.DataSink(), name='datasink') datasink.inputs.base_directory = "/Users/Katie/Dropbox/Data/habenula/derivatives/hb_test" # Connect alllllll the nodes!! hb_test_wf.connect(subj_iterable, 'subject_id', DataGrabber, 'subject_id') hb_test_wf.connect(DataGrabber, 'bold', moco, 'in_file') hb_test_wf.connect(moco, 'out_file', extractb0, 'in_file') hb_test_wf.connect(extractb0, 'roi_file', bet, 'in_file') hb_test_wf.connect(bet, 'out_file', datasink, '@epi_brain')
cluster_copes = Node(fsl.model.Cluster(), name='cluster') #cluster_copes.inputs.threshold = 3.1 cluster_copes.iterables = ('threshold', [2.3, 3.1]) cluster_copes.inputs.pthreshold = 0.001 cluster_copes.inputs.connectivity = 26 cluster_copes.inputs.out_threshold_file = 'thresh_zstat.nii.gz' cluster_copes.inputs.out_index_file = 'cluster_mask_zstat' cluster_copes.inputs.out_localmax_txt_file = 'lmax_zstat_std.txt' cluster_copes.inputs.use_mm = True #========================================================================================================================================================== #overlay thresh_zstat1 overlay_cope = Node(fsl.Overlay(), name='overlay') overlay_cope.inputs.auto_thresh_bg = True overlay_cope.inputs.stat_thresh = (3.1, 10) overlay_cope.inputs.transparency = True overlay_cope.inputs.out_file = 'rendered_thresh_zstat.nii.gz' overlay_cope.inputs.show_negative_stats = True overlay_cope.inputs.background_image = standard_brain #========================================================================================================================================================== #generate pics thresh_zstat1 slicer_cope = Node(fsl.Slicer(), name='slicer') slicer_cope.inputs.sample_axial = 2 slicer_cope.inputs.image_width = 2000 slicer_cope.inputs.out_file = 'rendered_thresh_zstat.png'
def overlay(wf_name='overlay', samethres=True): """ samethres: use False in case of voxel-based thresholding, where ptoz must be a mapnode (also in case of TFCE corr) - Get the maximum intensity value of the output thresholded image. This used is while rendering the Z statistic image:: fslstats zstat1_cluster_threshold.nii.gz -R arguments -R : output <min intensity> <max intensity> - Rendering. For details see `FEAT <http://www.fmrib.ox.ac.uk/fsl/feat5/detail.html#poststats>`_:: overlay 1 0 MNI152_T1_2mm_brain.nii.gz -a zstat1_cluster_threshold.nii.gz 2.30 15.67 zstat1_cluster_threshold_overlay.nii.gz slicer zstat1_cluster_threshold_overlay.nii.gz -L -A 750 zstat1_cluster_threshold_overlay.png The Z statistic range selected for rendering is automatically calculated by default, to run from red (minimum Z statistic after thresholding) to yellow (maximum Z statistic, here maximum intensity). """ overl = pe.Workflow(name=wf_name) inputnode = pe.Node( util.IdentityInterface(fields=['stat_image', 'threshold', 'bg_image']), name='inputspec') outputnode = pe.Node( util.IdentityInterface(fields=['overlay_threshold', 'rendered_image']), name='outputspec') #max and minimum intensity values image_stats = pe.MapNode(interface=fsl.ImageStats(), name='image_stats', iterfield=['in_file']) image_stats.inputs.op_string = '-p 100' #create tuple of z_threshold and max intensity value of threshold file if (samethres): create_tuple = pe.MapNode(util.Function( input_names=['infile_a', 'infile_b'], output_names=['out_file'], function=get_tuple), name='create_tuple', iterfield=['infile_b'], nested=True) else: create_tuple = pe.MapNode(util.Function( input_names=['infile_a', 'infile_b'], output_names=['out_file'], function=get_tuple), name='create_tuple', iterfield=['infile_a', 'infile_b'], nested=True) #colour activation overlaying overlay = pe.MapNode( interface=fsl.Overlay(), name='overlay', iterfield=['stat_image', 'stat_thresh', 'background_image']) overlay.inputs.transparency = True overlay.inputs.auto_thresh_bg = True overlay.inputs.out_type = 'float' #colour rendering slicer = pe.MapNode(interface=fsl.Slicer(), name='slicer', iterfield=['in_file']) #set max picture width slicer.inputs.image_width = 1750 # set output all axial slices into one picture slicer.inputs.all_axial = True overl.connect(inputnode, 'stat_image', image_stats, 'in_file') overl.connect(image_stats, 'out_stat', create_tuple, 'infile_b') overl.connect(inputnode, 'threshold', create_tuple, 'infile_a') overl.connect(inputnode, 'stat_image', overlay, 'stat_image') overl.connect(create_tuple, 'out_file', overlay, 'stat_thresh') overl.connect(inputnode, 'bg_image', overlay, 'background_image') overl.connect(overlay, 'out_file', slicer, 'in_file') overl.connect(overlay, 'out_file', outputnode, 'overlay_threshold') overl.connect(slicer, 'out_file', outputnode, 'rendered_image') return overl
(modelgen, conestimate, [('con_file', 'tcon_file')]), (modelestimate, conestimate, [('results_dir', 'stats_dir')]), (conestimate, ztopval, [(('zstats', lambda x: x[0]), 'in_file')]), (modelestimate, mergedestimate, [(('param_estimates', lambda x: x[0]), 'in3')]), (conestimate, mergedestimate, [(('copes', lambda x: x[0]), 'in1'), (('varcopes', lambda x: x[0]), 'in2')]), ]) """ Setup overlay workflow ---------------------- """ overlay = pe.Workflow(name='overlay') overlaystats = pe.MapNode(interface=fsl.Overlay(), name="overlaystats", iterfield=['stat_image']) overlaystats.inputs.show_negative_stats = True overlaystats.inputs.auto_thresh_bg = True """Use :class:`nipype.interfaces.fsl.Slicer` to create images of the overlaid statistical volumes for a report of the first-level results. """ slicestats = pe.MapNode(interface=fsl.Slicer(), name="slicestats", iterfield=['in_file']) slicestats.inputs.all_axial = True slicestats.inputs.image_width = 512 overlay.connect(overlaystats, 'out_file', slicestats, 'in_file')