def _bgplot(in_file, base_directory): from nipype.interfaces.io import DataSink if not in_file: return '' ds = DataSink(base_directory=base_directory, parameterization=False) setattr(ds.inputs, '@bg_fitting', in_file) return ds.run().outputs.out_file
def attach_canica(main_wf, wf_name="canica", **kwargs): """ Attach a nilearn CanICA interface to `main_wf`. Parameters ---------- main_wf: nipype Workflow wf_name: str Name of the preprocessing workflow kwargs: dict[str]->str input_node: str Name of the input node from where to connect the source `input_connect`. input_connection: str Name of the connection to obtain the source files. Nipype Inputs for `main_wf` --------------------------- datasink: nipype Node Returns ------- main_wf: nipype Workflow """ # Dependency workflows srcwf_name = kwargs['input_node'] srcconn_name = kwargs['input_connection'] src_wf = main_wf.get_node(srcwf_name) datasink = get_datasink(main_wf, name='datasink') base_outdir = datasink.inputs.base_directory ica_datasink = pe.Node(DataSink(parameterization=False, base_directory=base_outdir,), name="{}_datasink".format(wf_name)) # the list of the subjects files ica_subjs = pe.JoinNode(interface=IdentityInterface(fields=["ica_subjs"]), joinsource="infosrc", joinfield="ica_subjs", name="ica_subjs") # warp each subject to the group template ica = setup_node(CanICAInterface(), name="{}_ica".format(wf_name),) # Connect the nodes main_wf.connect([ # file list input (src_wf, ica_subjs, [(srcconn_name, "ica_subjs")]), # canica (ica_subjs, ica, [("ica_subjs", "in_files")]), # canica output (ica, ica_datasink, [("components", "canica.@components")]), (ica, ica_datasink, [("loadings", "canica.@loadings")]), (ica, ica_datasink, [("score", "canica.@score")]), ]) return main_wf
def build_output_node(self): """Build and connect an output node to the pipeline.""" import nipype.interfaces.utility as nutil from nipype.interfaces.io import DataSink import nipype.pipeline.engine as npe from clinica.utils.nipype import (fix_join, container_from_filename) from clinica.utils.filemanip import get_subject_id # Write node # ---------------------- write_node = npe.Node(name="WriteCaps", interface=DataSink()) write_node.inputs.base_directory = self.caps_directory write_node.inputs.parameterization = False # Get subject ID node # ---------------------- image_id_node = npe.Node(interface=nutil.Function( input_names=['bids_or_caps_file'], output_names=['image_id'], function=get_subject_id), name='ImageID') # Find container path from t1w filename # ---------------------- container_path = npe.Node(nutil.Function( input_names=['bids_or_caps_filename'], output_names=['container'], function=container_from_filename), name='ContainerPath') self.connect([ (self.input_node, image_id_node, [('input_nifti', 'bids_or_caps_file')]), (self.input_node, container_path, [('input_nifti', 'bids_or_caps_filename')]), # (image_id_node, write_node, [('image_id', '@image_id')]), (image_id_node, write_node, [('image_id', '@image_id')]), ]) subfolder = 'image_based' if self.parameters.get('extract_method') == 'slice': subfolder = 'slice_based' self.connect([(self.output_node, write_node, [('slices_rgb_T1', '@slices_rgb_T1')]), (self.output_node, write_node, [('slices_original_T1', '@slices_original_T1')])]) elif self.parameters.get('extract_method') == 'patch': subfolder = 'patch_based' self.connect([(self.output_node, write_node, [('patches_T1', '@patches_T1')])]) else: self.connect([(self.output_node, write_node, [('output_pt_file', '@output_pt_file')])]) self.connect([ (container_path, write_node, [(('container', fix_join, 'deeplearning_prepare_data', subfolder, 't1_linear'), 'container')]), ])
def test_DataSink_outputs(): output_map = dict(out_file=dict(), ) outputs = DataSink.output_spec() for key, metadata in output_map.items(): for metakey, value in metadata.items(): yield assert_equal, getattr(outputs.traits()[key], metakey), value
def datasink(base_directory, name, container=None, overwrite=False): output = pipe.Node(interface=DataSink(), name=name) output.inputs.base_directory = base_directory if container is not None: output.inputs.container = container output.inputs.parameterization = False output.overwrite = overwrite return output
def __init__(self,settings): # Define datasink node self.datasink = Node( DataSink( base_directory=os.path.join(settings['output_dir']), substitutions=[ ('_subject_','sub-') ] ), name='datasink' )
def create_DARTEL_wf(subj_list, file_template, work_dir, out_dir): ''' Aligns all images to a template (average of all images), then warps images into MNI space (using an SPM tissue probability map, see https://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf, section 25.4). subj_list: list of subject IDs e.g. [sub-001, sub-002] file_template: string to identify all files to align (using glob). e.g. file_template = os.path.join(work_dir, 'pag_mask', '*_pag_mask.nii') The template can identify a larger set of files, and the subject_list will grab a subset. e.g. The template may grab sub-001, sub-002, sub-003 ... But if the subject_list only includes sub-001, then only sub-001 will be used. This means the template can overgeneralize, but specific subjects can be easily excluded (e.g. for movement) work_dir: string, denoting path to working directory. out_dir: string, denoting output directory (results saved to work directory and output) ''' import nibabel as nib import numpy as np from nipype.interfaces.spm.preprocess import DARTEL, CreateWarped from nipype.interfaces.io import DataSink import nipype.pipeline.engine as pe import os from jtnipyutil.util import files_from_template # set up workflow. DARTEL_wf = pe.Workflow(name='DARTEL_wf') DARTEL_wf.base_dir = work_dir # get images images = files_from_template(subj_list, file_template) # set up DARTEL. dartel = pe.Node(interface=DARTEL(), name='dartel') dartel.inputs.image_files = [images] dartel_warp = pe.Node(interface=CreateWarped(), name='dartel_warp') dartel_warp.inputs.image_files = images # warp_data.inputs.flowfield_files = # from inputspec ################## Setup datasink. sinker = pe.Node(DataSink(parameterization=True), name='sinker') sinker.inputs.base_directory = out_dir DARTEL_wf.connect([ (dartel, dartel_warp, [('dartel_flow_fields', 'flowfield_files')]), (dartel, sinker, [('final_template_file', 'avg_template'), ('template_files', 'avg_template.@template_stages'), ('dartel_flow_fields', 'dartel_flow')]), (dartel_warp, sinker, [('warped_files', 'warped_PAG')]) ]) return DARTEL_wf
def build_output_node(self): """Build and connect an output node to the pipeline.""" import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from nipype.interfaces.io import DataSink from clinica.utils.nipype import container_from_filename, fix_join from .t1_linear_utils import get_substitutions_datasink # Writing node write_node = npe.Node(name="WriteCaps", interface=DataSink()) write_node.inputs.base_directory = self.caps_directory write_node.inputs.parameterization = False # Other nodes # ===================================== # Get substitutions to rename files get_ids = npe.Node( interface=nutil.Function( input_names=["bids_file"], output_names=["image_id_out", "subst_ls"], function=get_substitutions_datasink, ), name="GetIDs", ) # Find container path from t1w filename container_path = npe.Node( nutil.Function( input_names=["bids_or_caps_filename"], output_names=["container"], function=container_from_filename, ), name="ContainerPath", ) # fmt: off self.connect([ (self.input_node, container_path, [("t1w", "bids_or_caps_filename") ]), (container_path, write_node, [(("container", fix_join, "t1_linear"), "container")]), (self.output_node, get_ids, [("image_id", "bids_file")]), (get_ids, write_node, [("subst_ls", "substitutions")]), (get_ids, write_node, [("image_id_out", "@image_id")]), (self.output_node, write_node, [("outfile_reg", "@outfile_reg")]), (self.output_node, write_node, [("affine_mat", "@affine_mat")]), ]) if not (self.parameters.get("uncropped_image")): self.connect([ (self.output_node, write_node, [("outfile_crop", "@outfile_crop")]), ])
def define_workflow(subject_list, run_list, experiment_dir, output_dir): """run the smooth workflow given subject and runs""" # ExtractROI - skip dummy scans extract = Node(ExtractROI(t_min=4, t_size=-1, output_type='NIFTI'), name="extract") # Smooth - image smoothing smooth = Node(Smooth(fwhm=[8, 8, 8]), name="smooth") # Mask - applying mask to smoothed # mask_func = Node(ApplyMask(output_type='NIFTI'), # name="mask_func") # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['subject_id', 'run_num']), name="infosource") infosource.iterables = [('subject_id', subject_list), ('run_num', run_list)] # SelectFiles - to grab the data (alternativ to DataGrabber) func_file = opj( 'sub-{subject_id}', 'func', 'sub-{subject_id}_task-tsl_run-{run_num}_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz' ) templates = {'func': func_file} selectfiles = Node(SelectFiles(templates, base_directory=data_dir), name="selectfiles") # Datasink - creates output folder for important outputs datasink = Node(DataSink(base_directory=experiment_dir, container=output_dir), name="datasink") ## Use the following DataSink output substitutions substitutions = [('_subject_id_', 'sub-'), ('ssub', 'sub'), ('_space-MNI152NLin2009cAsym_desc-preproc_', '_fwhm-8_'), ('_fwhm_', ''), ('_roi', '')] substitutions += [('_run_num_%s' % r, '') for r in run_list] datasink.inputs.substitutions = substitutions # Create a preprocessing workflow preproc = Workflow(name='preproc') preproc.base_dir = opj(experiment_dir, working_dir) # Connect all components of the preprocessing workflow (spm smooth) preproc.connect([(infosource, selectfiles, [('subject_id', 'subject_id'), ('run_num', 'run_num')]), (selectfiles, extract, [('func', 'in_file')]), (extract, smooth, [('roi_file', 'in_files')]), (smooth, datasink, [('smoothed_files', 'preproc.@smooth') ])]) return preproc
def cope_merge_wf(subject_id, sink_directory, name='cope_merge_wf'): cope_merge_wf = Workflow(name='cope_merge_wf') info = dict( learning_cope=[['subject_id']], #dictionary for Datagrabber nonlearning_cope=[['subject_id']]) #node to grab corr and incorr cope files datasource = Node(DataGrabber(infields=['subject_id'], outfields=info.keys()), name='datasource') datasource.inputs.template = '*' datasource.inputs.subject_id = subject_id datasource.inputs.base_directory = os.path.abspath( '/home/data/madlab/data/mri/wmaze/frstlvl/model_LSS2') datasource.inputs.field_template = dict( learning_cope='%s/deriv/learn/*.nii.gz', nonlearning_cope='%s/deriv/nonlearn/*.nii.gz') datasource.inputs.template_args = info datasource.inputs.sort_filelist = True datasource.inputs.ignore_exception = False datasource.inputs.raise_on_empty = True #node to merge learning trials across all 6 runs merge_learning = Node(Merge(), name='merge_learning') merge_learning.inputs.dimension = 't' merge_learning.inputs.output_type = 'NIFTI_GZ' merge_learning.inputs.merged_file = 'cope_learning.nii.gz' merge_learning.inputs.tr = 2.00 cope_merge_wf.connect(datasource, 'learning_cope', merge_learning, 'in_files') #node to merge nonlearning trials across all 6 runs merge_nonlearning = Node(Merge(), name='merge_nonlearning') merge_nonlearning.inputs.dimension = 't' merge_nonlearning.inputs.output_type = 'NIFTI_GZ' merge_nonlearning.inputs.merged_file = 'cope_nonlearning.nii.gz' merge_nonlearning.inputs.tr = 2.00 cope_merge_wf.connect(datasource, 'nonlearning_cope', merge_nonlearning, 'in_files') #node to output data dsink = Node(DataSink(), name='dsink') dsink.inputs.base_directory = sink_directory dsink.inputs.container = subject_id cope_merge_wf.connect(merge_learning, 'merged_file', dsink, 'merged.@learning') cope_merge_wf.connect(merge_nonlearning, 'merged_file', dsink, 'merged.@nonlearning') return cope_merge_wf
def create_workflow(xfm_dir, xfm_pattern, atlas_dir, atlas_pattern, source_dir, source_pattern, work_dir, out_dir, name="new_data_to_atlas_space"): wf = Workflow(name=name) wf.base_dir = os.path.join(work_dir) datasource_source = Node(interface=DataGrabber(sort_filelist=True), name='datasource_source') datasource_source.inputs.base_directory = os.path.abspath(source_dir) datasource_source.inputs.template = source_pattern datasource_xfm = Node(interface=DataGrabber(sort_filelist=True), name='datasource_xfm') datasource_xfm.inputs.base_directory = os.path.abspath(xfm_dir) datasource_xfm.inputs.template = xfm_pattern datasource_atlas = Node(interface=DataGrabber(sort_filelist=True), name='datasource_atlas') datasource_atlas.inputs.base_directory = os.path.abspath(atlas_dir) datasource_atlas.inputs.template = atlas_pattern resample = MapNode(interface=Resample(sinc_interpolation=True), name='resample_', iterfield=['input_file', 'transformation']) wf.connect(datasource_source, 'outfiles', resample, 'input_file') wf.connect(datasource_xfm, 'outfiles', resample, 'transformation') wf.connect(datasource_atlas, 'outfiles', resample, 'like') bigaverage = Node(interface=BigAverage(output_float=True, robust=False), name='bigaverage', iterfield=['input_file']) wf.connect(resample, 'output_file', bigaverage, 'input_files') datasink = Node(interface=DataSink(base_directory=out_dir, container=out_dir), name='datasink') wf.connect([(bigaverage, datasink, [('output_file', 'average')])]) wf.connect([(resample, datasink, [('output_file', 'atlas_space')])]) wf.connect([(datasource_xfm, datasink, [('outfiles', 'transforms')])]) return wf
def cli(ctx, working_dir, name, results, save, container, image, keep, force): if not ctx.obj: ctx.obj = {} ctx.obj['save'] = save ctx.obj['container'] = container ctx.obj['wdir'] = click.format_filename(working_dir) ctx.obj['output'] = results ctx.obj['force'] = force ctx.obj['temp'] = '' ctx.obj['container_dir'] = '' if not ctx.obj['container']: datasink = pe.Node(DataSink(base_directory=ctx.obj['wdir'], container=ctx.obj['output']), name="datasink") wf = pe.Workflow(name=name, base_dir=ctx.obj['wdir']) else: if find_spec("docker") is None: click.echo( 'The --container option was specified but the docker package is not installed.' ) sys.exit(1) ctx.obj['save'] = True ctx.obj['temp'] = tempfile.mkdtemp(dir=ctx.obj['wdir']) ctx.obj['container_dir'] = '/tmp' datasink = pe.Node(DataSink(base_directory=ctx.obj['container_dir'], container=os.path.join( ctx.obj['container_dir'], 'output')), name="datasink") wf = pe.Workflow(name=name, base_dir=ctx.obj['temp']) wf.add_nodes([datasink]) ctx.obj['workflow'] = wf ctx.obj['results'] = datasink
def build_output_node(self): """Build and connect an output node to the pipeline. """ import nipype.interfaces.utility as nutil from nipype.interfaces.io import DataSink import nipype.pipeline.engine as npe from clinica.utils.nipype import fix_join from .t1_linear_utils import (container_from_filename, get_substitutions_datasink) # Writing node write_node = npe.Node( name="WriteCaps", interface=DataSink() ) write_node.inputs.base_directory = self.caps_directory write_node.inputs.parameterization = False # Other nodes # ===================================== # Get substitutions to rename files get_ids = npe.Node( interface=nutil.Function( input_names=['bids_file'], output_names=['image_id_out', 'subst_ls'], function=get_substitutions_datasink), name="GetIDs") # Find container path from t1w filename container_path = npe.Node( nutil.Function( input_names=['bids_or_caps_filename'], output_names=['container'], function=container_from_filename), name='ContainerPath') self.connect([ (self.input_node, container_path, [('t1w', 'bids_or_caps_filename')]), (container_path, write_node, [(('container', fix_join, 't1_linear'), 'container')]), (self.output_node, get_ids, [('image_id', 'bids_file')]), (get_ids, write_node, [('subst_ls', 'substitutions')]), (get_ids, write_node, [('image_id_out', '@image_id')]), (self.output_node, write_node, [('outfile_reg', '@outfile_reg')]), (self.output_node, write_node, [('affine_mat', '@affine_mat')]), ]) if (self.parameters.get('crop_image')): self.connect([ (self.output_node, write_node, [('outfile_crop', '@outfile_crop')]), ])
def smooth_images(write_dir, **template_dict): """This function runs smoothing on input images. Ex: modulated images""" from nipype.interfaces import spm from nipype.interfaces.io import DataSink smooth = pe.Node(interface=spm.Smooth(), name='smooth') smooth.inputs.paths = template_dict['spm_path'] smooth.inputs.implicit_masking = template_dict['implicit_masking'] smooth.inputs.in_files = glob.glob(os.path.join(write_dir, 'mwc*.nii')) smooth.inputs.fwhm = template_dict['FWHM_SMOOTH'] vbm_smooth_modulated_images = pe.Workflow( name="vbm_smooth_modulated_images") datasink = pe.Node(interface=DataSink(), name='datasink') datasink.inputs.base_directory = write_dir vbm_smooth_modulated_images.connect([(smooth, datasink, [('smoothed_files', write_dir)])]) with stdchannel_redirected(sys.stderr, os.devnull): vbm_smooth_modulated_images.run()
def index_lesion_workflow(msid, mseid, lesion): import nipype.interfaces.ants as ants from nipype.pipeline.engine import Node, Workflow, MapNode from nipype.interfaces.io import DataSink, DataGrabber from nipype.interfaces.utility import IdentityInterface, Function import nipype.interfaces.fsl as fsl from nipype.utils.filemanip import load_json working_directory = '/working/henry_temp/keshavan/' output_directory = os.path.split(lesion)[0] register = Workflow(name="indexed_lesion_{0}_{1}".format(msid, mseid)) register.base_dir = working_directory inputnode = Node(IdentityInterface(fields=["lesion"]), name="inputspec") inputnode.inputs.lesion = lesion bin_math = Node(fsl.BinaryMaths(), name="Convert_to_binary") bin_math.inputs.operand_value = 1 bin_math.inputs.operation = 'min' register.connect(inputnode, "lesion", bin_math, "in_file") cluster_lesion = Node(fsl.Cluster(threshold=0.0001, out_index_file=True, use_mm=True), name="cluster_lesion") sinker = Node(DataSink(), name="sinker") sinker.inputs.base_directory = output_directory sinker.inputs.container = '.' sinker.inputs.substitutions = [('_maths', '')] register.connect(bin_math, "out_file", cluster_lesion, "in_file") register.connect(cluster_lesion, "index_file", sinker, "@cluster") from nipype.interfaces.freesurfer import SegStats segstats_lesion = Node(SegStats(), name="segstats_lesion") register.connect(cluster_lesion, "index_file", segstats_lesion, "segmentation_file") register.connect(segstats_lesion, "summary_file", sinker, "@summaryfile") register.write_graph(graph2use='orig') register.config["Execution"] = { "keep_inputs": True, "remove_unnecessary_outputs": False } return register
def runNipypeBet(controller, subject_list, anatomical_id, proj_directory): infosource = Node(IdentityInterface(fields=['subject_id']), name="infosource") infosource.iterables = [('subject_id', subject_list)] #anat_file = opj('{subject_id}','{subject_id}_{anatomical_id}.nii') seperator = '' concat_words = ('{subject_id}_', anatomical_id, '.nii.gz') anat_file_name = seperator.join(concat_words) if controller.b_radiological_convention.get() == True: anat_file = opj('{subject_id}', anat_file_name) else: anat_file = opj('{subject_id}', 'Intermediate_Files', 'Original_Files', anat_file_name) templates = {'anat': anat_file} selectfiles = Node(SelectFiles(templates, base_directory=proj_directory), name="selectfiles") skullstrip = Node(BET(robust=True, frac=0.5, vertical_gradient=0, output_type='NIFTI_GZ'), name="skullstrip") # Datasink - creates output folder for important outputs datasink = Node(DataSink(base_directory=proj_directory), name="datasink") wf_sub = Workflow(name="wf_sub") wf_sub.base_dir = proj_directory wf_sub.connect(infosource, "subject_id", selectfiles, "subject_id") wf_sub.connect(selectfiles, "anat", skullstrip, "in_file") wf_sub.connect(skullstrip, "out_file", datasink, "bet.@out_file") substitutions = [('%s_brain' % (anatomical_id), 'brain')] # Feed the substitution strings to the DataSink node datasink.inputs.substitutions = substitutions # Run the workflow again with the substitutions in place wf_sub.run(plugin='MultiProc') return 'brain'
def deface(in_file): deface_wf = pe.Workflow('deface_wf') inputnode = pe.Node(niu.IdentityInterface(['in_file']), name='inputnode') # outputnode = pe.Node(niu.IdentityInterface(['out_file']), # name='outputnode') bet = pe.Node(BET(mask=True), name='bet') quickshear = pe.Node(Quickshear(), name='quickshear') sinker = pe.Node(DataSink(), name='store_results') sinker.inputs.base_directory = os.getcwd() deface_wf.connect([ (inputnode, bet, [('in_file', 'in_file')]), (inputnode, quickshear, [('in_file', 'in_file')]), (bet, quickshear, [('mask_file', 'mask_file')]), (quickshear, sinker, [('out_file', '@')]), ]) inputnode.inputs.in_file = in_file res = deface_wf.run()
def cli(ctx, working_dir, name, results): if not ctx.obj: ctx.obj = {} if not working_dir: ctx.obj['wdir'] = os.path.abspath('.') else: ctx.obj['wdir'] = click.format_filename(working_dir) if not results: ctx.obj['output'] = 'trampolino' else: ctx.obj['output'] = results datasink = pe.Node(DataSink(base_directory=ctx.obj['wdir'], container=ctx.obj['output']), name="datasink") if not name: name = 'meta' wf = pe.Workflow(name=name, base_dir=ctx.obj['wdir']) wf.add_nodes([datasink]) ctx.obj['workflow'] = wf ctx.obj['results'] = datasink
def test_DataSink_inputs(): input_map = dict(_outputs=dict(usedefault=True, ), base_directory=dict(), container=dict(), ignore_exception=dict(nohash=True, usedefault=True, ), parameterization=dict(usedefault=True, ), regexp_substitutions=dict(), remove_dest_dir=dict(usedefault=True, ), strip_dir=dict(), substitutions=dict(), ) inputs = DataSink.input_spec() for key, metadata in input_map.items(): for metakey, value in metadata.items(): yield assert_equal, getattr(inputs.traits()[key], metakey), value
def make_workflow(config, strip_standard, moving_image, fixed_image, fixed_is_standard, output_dir): log.info('Creating Workflow...') # Declare and create output directories workflow_directory = '/flywheel/v0/nipype/workflow' Path(workflow_directory).mkdir(parents=True) wf = Workflow(name='moving2fixed', base_dir=workflow_directory) # Create the registration node registration_node = create_registration_node(config, moving_image) # If the fixed image is standard and we are to skullstrip it, do that log.debug('\tChecking if fixed is standard') if strip_standard and fixed_is_standard: log.debug('\t fixed is standard, and skull strip true. Adding strip node') skullstrip_node = skullstrip_standard_node() log.debug('\tconnecting to wf') wf.connect(skullstrip_node, "output_product_image", registration_node, "fixed_image") else: log.debug('adding fixed image to registration node') registration_node.inputs.fixed_image = fixed_image # Create data sink for output log.debug('\tCreating sink') sink = Node(DataSink(), name='sinker') # Set the sink output to the flywheel output log.debug(f'\tSetting sink output to {output_dir}') sink.inputs.base_directory = str(output_dir) wf.connect(registration_node, 'warped_image', sink, 'Registered_image') if config['save_transform']: log.debug('\tsaving transformation parameters') wf.connect(registration_node, 'forward_warp_field', sink, 'forward_warp_field') wf.connect(registration_node, 'inverse_warp_field', sink, 'inverse_warp_field') wf.connect(registration_node, 'out_matrix', sink, 'out_matrix') log.info('...Complete!') return (wf)
def create_corthick_wf(): import nipype.pipeline.engine as pe # pypeline engine import os from nipype import IdentityInterface from nipype.interfaces.ants.segmentation import KellyKapowski from nipype.interfaces.io import DataSink corthick_wf = pe.Workflow(name='corthick_wf') inputspec = pe.Node(IdentityInterface( fields=['seg_file', 'wmprob_file', 'out_dir'], mandatory_inputs=False), name='inputspec') DiReCT = pe.Node(KellyKapowski(), name='DiReCt') sinker = pe.Node(DataSink(parameterization=True), name='sinker') corthick_wf.connect([ (inputspec, DiReCT, [('seg_file', 'segmentation_image'), ('wmprob_file', 'white_matter_prob_image')]), (inputspec, sinker, [('out_dir', 'base_directory')]), (DiReCT, sinker, [('cortical_thickness', 'out.@thick'), ('warped_white_matter', 'out.@wm')]), ]) return corthick_wf
def create_motion_confound_workflow(order=2, fd_cutoff=.2, name='motion_confound'): input_node = pe.Node(interface=IdentityInterface( fields=['par_file', 'output_directory', 'sub_id']), name='inputspec') output_node = pe.Node( interface=IdentityInterface(fields=['out_fd', 'out_ext_moco']), name='outputspec') datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False extend_motion_parameters = pe.MapNode(Extend_motion_parameters, iterfield=['par_file'], name='extend_motion_parameters') extend_motion_parameters.inputs.order = order framewise_disp = pe.MapNode(FramewiseDisplacement(parameter_source='FSL'), iterfield=['in_file'], name='framewise_disp') mcf_wf = pe.Workflow(name=name) mcf_wf.connect(input_node, 'output_directory', datasink, 'base_directory') mcf_wf.connect(input_node, 'sub_id', datasink, 'container') mcf_wf.connect(input_node, 'par_file', extend_motion_parameters, 'par_file') mcf_wf.connect(input_node, 'par_file', framewise_disp, 'in_file') mcf_wf.connect(extend_motion_parameters, 'out_ext', output_node, 'out_ext_moco') mcf_wf.connect(framewise_disp, 'out_file', output_node, 'out_fd') mcf_wf.connect(extend_motion_parameters, 'out_ext', datasink, 'confounds') mcf_wf.connect(framewise_disp, 'out_file', datasink, 'confounds.@df') return mcf_wf
def create_volatlas_workflow(wf_name, wf_base_dir, subject_list, cnxn_names, fstr_dict, ref_file, agg_cnxn_names_dict): from nipype.pipeline import engine as pe from nipype.pipeline.engine import Node, JoinNode, MapNode, Workflow from nipype.pipeline.engine.utils import IdentityInterface from nipype.interfaces import Function from nipype.interfaces.io import DataSink """ Variables """ dpy_fstr = fstr_dict['dpy'] warp_fstr = fstr_dict['warp'] parc_fstr = fstr_dict['parc'] cnxn_mapping_fstr = fstr_dict['cnxn_mapping'] """ Node: Infosource """ # (iterates over subjects) def mirror(subject_id): return subject_id mirror_npfunc = Function(['subject_id'], ['subject_id'], mirror) node__infosource = Node(interface=mirror_npfunc, name="infosource") node__infosource.iterables = [("subject_id", subject_list)] """ Node: Get data """ # (also iterates over cnxn ids) def get_sub_files_func(subject_id, cnxn_name, dpy_fstr, warp_fstr, parc_fstr, cnxn_mapping_fstr): dpy_file = dpy_fstr % subject_id cnxn_mapping_file = cnxn_mapping_fstr % subject_id parc_file = parc_fstr % subject_id warp_file = warp_fstr % subject_id return dpy_file, parc_file, warp_file, cnxn_mapping_file, cnxn_name, subject_id get_sub_files_npfunc = Function([ 'subject_id', 'cnxn_name', 'dpy_fstr', 'warp_fstr', 'parc_fstr', 'cnxn_mapping_fstr' ], [ 'dpy_file', 'parc_file', 'warp_file', 'cnxn_mapping_file', 'cnxn_name', 'subject_id' ], get_sub_files_func) node__datasource = Node(interface=get_sub_files_npfunc, name='datasource') node__datasource.inputs.dpy_fstr = dpy_fstr node__datasource.inputs.parc_fstr = parc_fstr node__datasource.inputs.warp_fstr = warp_fstr node__datasource.inputs.cnxn_mapping_fstr = cnxn_mapping_fstr node__datasource.iterables = [('cnxn_name', cnxn_names)] """ Node: Make sub cnxn visitation map """ make_sub_vismap_npfunc = Function([ 'sub', 'dpy_file', 'parc_file', 'warp_file', 'ref_file', 'cnxn_inds_file', 'cnxn_name', 'vismap_fstr' ], ['sub_vismap_file'], make_sub_cnxn_visitation_map) node__makesubvismap = Node(interface=make_sub_vismap_npfunc, name="make_sub_vismap") node__makesubvismap.inputs.ref_file = ref_file node__makesubvismap.inputs.vismap_fstr = 'temp_vismap_%s.nii.gz' #node__makesubvismap.inputs.overwrite=True """ Node: make grp cnxn visitation map """ make_grp_vismap_npfunc = Function( ['cnxn_name', 'sub_vismaps', 'grp_vismap_fstr', 'subs_list'], ['grp_vismap_fpath', 'grp_vismap_norm_fpath', 'subs_list_file'], make_group_cnxn_visitation_map) node__makegrpvismap = JoinNode(interface=make_grp_vismap_npfunc, name='make_grp_vismap', joinsource="infosource", joinfield=["sub_vismaps", 'subs_list']) #subject_id") node__makegrpvismap.inputs.grp_vismap_fstr = 'grp_vismap_%s.nii.gz' # this needs to be changed to come from previous node in wf """ Node: aggregate group cnxn visitation map """ # (to do...) agg_grp_vismap_npfunc = Function(['in_files', 'cnxn_names', 'outfname'], ['agg_image_file', 'agg_list_file'], aggregate_grp_vismap, imports=['import os']) node__agggrpvismap = JoinNode(interface=agg_grp_vismap_npfunc, name='agg_grp_vismap', joinsource="datasource", joinfield=["in_files"]) node__agggrpvismap.iterables = [("cnxn_names", agg_cnxn_names_dict.values()), ("outfname", agg_cnxn_names_dict.keys())] node__agggrpvismap.synchronize = True """ Node: datasink """ # I want to use a mapnode for this, but can't get it to work # so have to settle with this followed by a command line copy... # (if you don't have a mapnode, just get same result as outputs of agggrpvismap node...) node__datasink = Node(DataSink(), name='datasink') node__datasink.inputs.base_directory = wf_base_dir #node__datasinkniifile = MapNode(DataSink(infields=['agg_image_file']),name='ds_nii', iterfield=['agg_image_file']) #node__datasinkniifile.inputs.base_directory=wf_base_dir #node__datasinktxtfile = MapNode(DataSink(infields=['agg_list_file']),name='ds_txt', iterfield=['agg_list_file']) #node__datasinktxtfile.inputs.base_directory=wf_base_dir """ Workflow: put it all together """ wf = pe.Workflow(name=wf_name) wf.base_dir = wf_base_dir wf.connect(node__infosource, 'subject_id', node__datasource, 'subject_id') wf.connect(node__datasource, 'subject_id', node__makesubvismap, 'sub') wf.connect(node__datasource, 'dpy_file', node__makesubvismap, 'dpy_file') wf.connect(node__datasource, 'parc_file', node__makesubvismap, 'parc_file') wf.connect(node__datasource, 'warp_file', node__makesubvismap, 'warp_file') wf.connect(node__datasource, 'cnxn_mapping_file', node__makesubvismap, 'cnxn_inds_file') wf.connect(node__datasource, 'cnxn_name', node__makesubvismap, 'cnxn_name') wf.connect(node__makesubvismap, 'sub_vismap_file', node__makegrpvismap, 'sub_vismaps') wf.connect(node__datasource, 'cnxn_name', node__makegrpvismap, 'cnxn_name') wf.connect(node__datasource, 'subject_id', node__makegrpvismap, 'subs_list') wf.connect(node__makegrpvismap, 'grp_vismap_norm_fpath', node__agggrpvismap, 'in_files') wf.connect(node__agggrpvismap, 'agg_image_file', node__datasink, '@agg_image_file') wf.connect(node__agggrpvismap, 'agg_list_file', node__datasink, '@agg_list_file') #wf.connect(node__agggrpvismap, 'agg_image_file', node__datasinkniifile, '@agg_image_file') #wf.connect(node__agggrpvismap, 'agg_list_file', node__datasinktxtfile, '@agg_list_file') return wf
def create_all_calcarine_reward_2_h5_workflow( analysis_info, name='all_calcarine_reward_nii_2_h5'): import os.path as op import tempfile import nipype.pipeline as pe from nipype.interfaces import fsl from nipype.interfaces.utility import Function, Merge, IdentityInterface from spynoza.nodes.utils import get_scaninfo, dyns_min_1, topup_scan_params, apply_scan_params from nipype.interfaces.io import SelectFiles, DataSink # Importing of custom nodes from spynoza packages; assumes that spynoza is installed: # pip install git+https://github.com/spinoza-centre/spynoza.git@develop from utils.utils import mask_nii_2_hdf5, combine_eye_hdfs_to_nii_hdf input_node = pe.Node( IdentityInterface(fields=['sub_id', 'preprocessed_data_dir']), name='inputspec') # i/o node datasource_templates = dict(mcf='{sub_id}/mcf/*.nii.gz', psc='{sub_id}/psc/*.nii.gz', tf='{sub_id}/tf/*.nii.gz', GLM='{sub_id}/GLM/*.nii.gz', eye='{sub_id}/eye/h5/*.h5', rois='{sub_id}/roi/*_vol.nii.gz') datasource = pe.Node(SelectFiles(datasource_templates, sort_filelist=True, raise_on_empty=False), name='datasource') hdf5_psc_masker = pe.Node(Function( input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_psc_masker') hdf5_psc_masker.inputs.folder_alias = 'psc' hdf5_psc_masker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5') hdf5_tf_masker = pe.Node(Function( input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_tf_masker') hdf5_tf_masker.inputs.folder_alias = 'tf' hdf5_psc_masker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5') hdf5_mcf_masker = pe.Node(Function( input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_mcf_masker') hdf5_mcf_masker.inputs.folder_alias = 'mcf' hdf5_GLM_masker = pe.Node(Function( input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_GLM_masker') hdf5_GLM_masker.inputs.folder_alias = 'GLM' eye_hdfs_to_nii_masker = pe.Node(Function( input_names=['nii_hdf5_file', 'eye_hdf_filelist', 'new_alias'], output_names=['nii_hdf5_file'], function=combine_eye_hdfs_to_nii_hdf), name='eye_hdfs_to_nii_masker') eye_hdfs_to_nii_masker.inputs.new_alias = 'eye' # node for datasinking datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False all_calcarine_reward_nii_2_h5_workflow = pe.Workflow(name=name) all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'preprocessed_data_dir', datasink, 'base_directory') all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'sub_id', datasink, 'container') all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'preprocessed_data_dir', datasource, 'base_directory') all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'sub_id', datasource, 'sub_id') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'psc', hdf5_psc_masker, 'in_files') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois', hdf5_psc_masker, 'mask_files') # the hdf5_file is created by the psc node, and then passed from masker to masker on into the datasink. all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_psc_masker, 'hdf5_file', hdf5_tf_masker, 'hdf5_file') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'tf', hdf5_tf_masker, 'in_files') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois', hdf5_tf_masker, 'mask_files') all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_tf_masker, 'hdf5_file', hdf5_mcf_masker, 'hdf5_file') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'mcf', hdf5_mcf_masker, 'in_files') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois', hdf5_mcf_masker, 'mask_files') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'GLM', hdf5_GLM_masker, 'in_files') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois', hdf5_GLM_masker, 'mask_files') all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_mcf_masker, 'hdf5_file', hdf5_GLM_masker, 'hdf5_file') all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_GLM_masker, 'hdf5_file', eye_hdfs_to_nii_masker, 'nii_hdf5_file') all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'eye', eye_hdfs_to_nii_masker, 'eye_hdf_filelist') all_calcarine_reward_nii_2_h5_workflow.connect(eye_hdfs_to_nii_masker, 'nii_hdf5_file', datasink, 'h5') return all_calcarine_reward_nii_2_h5_workflow
copemerge = Node(fsl.Merge(dimension='t', in_files=listCopeFiles), name="copemerge") # merging varcope files varcopemerge = Node(fsl.Merge(dimension='t', in_files=listVarcopeFiles), name="varcopemerge") # merging mask files maskmerge = Node(fsl.Merge(dimension='t', in_files=listMaskFiles), name="maskmerge") # calculating the minimum across time points on merged mask image minmask = Node(fsl.MinImage(), name="minmask") # creating datasink to collect outputs datasink = Node(DataSink(base_directory=os.path.join( outDir, 'FingerFootLips_Test_Cope6_Handedness')), name='datasink') ########### # # SETTING UP THE WORKFLOW NODES # ########### # creating the workflow secondLevel = Workflow(name="Level2", base_dir=outDir) # connecting nodes secondLevel.connect(level2design, 'design_mat', flameo, 'design_file') secondLevel.connect(level2design, 'design_con', flameo, 't_con_file') secondLevel.connect(level2design, 'design_grp', flameo, 'cov_split_file')
'fwhm-{fwhm_id}_sasub-{subject_id}_task-{task_name}_bold.nii'), 'anat': opj('/data/wellbeing_analysis/datasink/preproc', 'sub-{subject_id}', 'task-{task_name}', 'sub-{subject_id}_T1w_brain.nii.gz'), 'transform': opj('/data/wellbeing_analysis/datasink/antsreg', 'sub-{subject_id}', 'transformComposite.h5') } selectfiles = Node(SelectFiles(templates, base_directory=experiment_dir, sort_filelist=True), name="selectfiles") # Datasink - creates output folder for important outputs datasink = Node(DataSink(base_directory=experiment_dir, container=output_dir), name="datasink") # Use the following DataSink output substitutions substitutions = [ ('_fwhm_id_%s_subject_id_%s_task_name_empathy/_apply_norm_anat0' % (f, sub), 'sub-%s/anat/' % (sub)) for f in fwhm for sub in subject_list ] subjFolders = [ ('_fwhm_id_%s_subject_id_%s_task_name_empathy/_apply_norm_bold0' % (f, sub), 'sub-%s/bold/task-empathy/' % (sub)) for f in fwhm for sub in subject_list ] substitutions.extend(subjFolders)
def create_workflow(files, target_file, subject_id, TR, slice_times, norm_threshold=1, num_components=5, vol_fwhm=None, surf_fwhm=None, lowpass_freq=-1, highpass_freq=-1, subjects_dir=None, sink_directory=os.getcwd(), target_subject=['fsaverage3', 'fsaverage4'], name='resting'): wf = Workflow(name=name) # Rename files in case they are named identically name_unique = MapNode(Rename(format_string='rest_%(run)02d'), iterfield=['in_file', 'run'], name='rename') name_unique.inputs.keep_ext = True name_unique.inputs.run = list(range(1, len(files) + 1)) name_unique.inputs.in_file = files realign = Node(interface=spm.Realign(), name="realign") realign.inputs.jobtype = 'estwrite' num_slices = len(slice_times) slice_timing = Node(interface=spm.SliceTiming(), name="slice_timing") slice_timing.inputs.num_slices = num_slices slice_timing.inputs.time_repetition = TR slice_timing.inputs.time_acquisition = TR - TR / float(num_slices) slice_timing.inputs.slice_order = (np.argsort(slice_times) + 1).tolist() slice_timing.inputs.ref_slice = int(num_slices / 2) # Comute TSNR on realigned data regressing polynomials upto order 2 tsnr = MapNode(TSNR(regress_poly=2), iterfield=['in_file'], name='tsnr') wf.connect(slice_timing, 'timecorrected_files', tsnr, 'in_file') # Compute the median image across runs calc_median = Node(Function(input_names=['in_files'], output_names=['median_file'], function=median, imports=imports), name='median') wf.connect(tsnr, 'detrended_file', calc_median, 'in_files') """Segment and Register """ registration = create_reg_workflow(name='registration') wf.connect(calc_median, 'median_file', registration, 'inputspec.mean_image') registration.inputs.inputspec.subject_id = subject_id registration.inputs.inputspec.subjects_dir = subjects_dir registration.inputs.inputspec.target_image = target_file """Use :class:`nipype.algorithms.rapidart` to determine which of the images in the functional series are outliers based on deviations in intensity or movement. """ art = Node(interface=ArtifactDetect(), name="art") art.inputs.use_differences = [True, True] art.inputs.use_norm = True art.inputs.norm_threshold = norm_threshold art.inputs.zintensity_threshold = 9 art.inputs.mask_type = 'spm_global' art.inputs.parameter_source = 'SPM' """Here we are connecting all the nodes together. Notice that we add the merge node only if you choose to use 4D. Also `get_vox_dims` function is passed along the input volume of normalise to set the optimal voxel sizes. """ wf.connect([ (name_unique, realign, [('out_file', 'in_files')]), (realign, slice_timing, [('realigned_files', 'in_files')]), (slice_timing, art, [('timecorrected_files', 'realigned_files')]), (realign, art, [('realignment_parameters', 'realignment_parameters')]), ]) def selectindex(files, idx): import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename( np.array(filename_to_list(files))[idx].tolist()) mask = Node(fsl.BET(), name='getmask') mask.inputs.mask = True wf.connect(calc_median, 'median_file', mask, 'in_file') # get segmentation in normalized functional space def merge_files(in1, in2): out_files = filename_to_list(in1) out_files.extend(filename_to_list(in2)) return out_files # filter some noise # Compute motion regressors motreg = Node(Function( input_names=['motion_params', 'order', 'derivatives'], output_names=['out_files'], function=motion_regressors, imports=imports), name='getmotionregress') wf.connect(realign, 'realignment_parameters', motreg, 'motion_params') # Create a filter to remove motion and art confounds createfilter1 = Node(Function( input_names=['motion_params', 'comp_norm', 'outliers', 'detrend_poly'], output_names=['out_files'], function=build_filter1, imports=imports), name='makemotionbasedfilter') createfilter1.inputs.detrend_poly = 2 wf.connect(motreg, 'out_files', createfilter1, 'motion_params') wf.connect(art, 'norm_files', createfilter1, 'comp_norm') wf.connect(art, 'outlier_files', createfilter1, 'outliers') filter1 = MapNode(fsl.GLM(out_f_name='F_mcart.nii', out_pf_name='pF_mcart.nii', demean=True), iterfield=['in_file', 'design', 'out_res_name'], name='filtermotion') wf.connect(slice_timing, 'timecorrected_files', filter1, 'in_file') wf.connect(slice_timing, ('timecorrected_files', rename, '_filtermotart'), filter1, 'out_res_name') wf.connect(createfilter1, 'out_files', filter1, 'design') createfilter2 = MapNode(Function(input_names=[ 'realigned_file', 'mask_file', 'num_components', 'extra_regressors' ], output_names=['out_files'], function=extract_noise_components, imports=imports), iterfield=['realigned_file', 'extra_regressors'], name='makecompcorrfilter') createfilter2.inputs.num_components = num_components wf.connect(createfilter1, 'out_files', createfilter2, 'extra_regressors') wf.connect(filter1, 'out_res', createfilter2, 'realigned_file') wf.connect(registration, ('outputspec.segmentation_files', selectindex, [0, 2]), createfilter2, 'mask_file') filter2 = MapNode(fsl.GLM(out_f_name='F.nii', out_pf_name='pF.nii', demean=True), iterfield=['in_file', 'design', 'out_res_name'], name='filter_noise_nosmooth') wf.connect(filter1, 'out_res', filter2, 'in_file') wf.connect(filter1, ('out_res', rename, '_cleaned'), filter2, 'out_res_name') wf.connect(createfilter2, 'out_files', filter2, 'design') wf.connect(mask, 'mask_file', filter2, 'mask') bandpass = Node(Function( input_names=['files', 'lowpass_freq', 'highpass_freq', 'fs'], output_names=['out_files'], function=bandpass_filter, imports=imports), name='bandpass_unsmooth') bandpass.inputs.fs = 1. / TR bandpass.inputs.highpass_freq = highpass_freq bandpass.inputs.lowpass_freq = lowpass_freq wf.connect(filter2, 'out_res', bandpass, 'files') """Smooth the functional data using :class:`nipype.interfaces.spm.Smooth`. """ smooth = Node(interface=spm.Smooth(), name="smooth") smooth.inputs.fwhm = vol_fwhm wf.connect(bandpass, 'out_files', smooth, 'in_files') collector = Node(Merge(2), name='collect_streams') wf.connect(smooth, 'smoothed_files', collector, 'in1') wf.connect(bandpass, 'out_files', collector, 'in2') """ Transform the remaining images. First to anatomical and then to target """ warpall = MapNode(ants.ApplyTransforms(), iterfield=['input_image'], name='warpall') warpall.inputs.input_image_type = 3 warpall.inputs.interpolation = 'Linear' warpall.inputs.invert_transform_flags = [False, False] warpall.inputs.terminal_output = 'file' warpall.inputs.reference_image = target_file warpall.inputs.args = '--float' warpall.inputs.num_threads = 1 # transform to target wf.connect(collector, 'out', warpall, 'input_image') wf.connect(registration, 'outputspec.transforms', warpall, 'transforms') mask_target = Node(fsl.ImageMaths(op_string='-bin'), name='target_mask') wf.connect(registration, 'outputspec.anat2target', mask_target, 'in_file') maskts = MapNode(fsl.ApplyMask(), iterfield=['in_file'], name='ts_masker') wf.connect(warpall, 'output_image', maskts, 'in_file') wf.connect(mask_target, 'out_file', maskts, 'mask_file') # map to surface # extract aparc+aseg ROIs # extract subcortical ROIs # extract target space ROIs # combine subcortical and cortical rois into a single cifti file ####### # Convert aparc to subject functional space # Sample the average time series in aparc ROIs sampleaparc = MapNode( freesurfer.SegStats(default_color_table=True), iterfield=['in_file', 'summary_file', 'avgwf_txt_file'], name='aparc_ts') sampleaparc.inputs.segment_id = ([8] + list(range(10, 14)) + [17, 18, 26, 47] + list(range(49, 55)) + [58] + list(range(1001, 1036)) + list(range(2001, 2036))) wf.connect(registration, 'outputspec.aparc', sampleaparc, 'segmentation_file') wf.connect(collector, 'out', sampleaparc, 'in_file') def get_names(files, suffix): """Generate appropriate names for output files """ from nipype.utils.filemanip import (split_filename, filename_to_list, list_to_filename) out_names = [] for filename in files: _, name, _ = split_filename(filename) out_names.append(name + suffix) return list_to_filename(out_names) wf.connect(collector, ('out', get_names, '_avgwf.txt'), sampleaparc, 'avgwf_txt_file') wf.connect(collector, ('out', get_names, '_summary.stats'), sampleaparc, 'summary_file') # Sample the time series onto the surface of the target surface. Performs # sampling into left and right hemisphere target = Node(IdentityInterface(fields=['target_subject']), name='target') target.iterables = ('target_subject', filename_to_list(target_subject)) samplerlh = MapNode(freesurfer.SampleToSurface(), iterfield=['source_file'], name='sampler_lh') samplerlh.inputs.sampling_method = "average" samplerlh.inputs.sampling_range = (0.1, 0.9, 0.1) samplerlh.inputs.sampling_units = "frac" samplerlh.inputs.interp_method = "trilinear" samplerlh.inputs.smooth_surf = surf_fwhm # samplerlh.inputs.cortex_mask = True samplerlh.inputs.out_type = 'niigz' samplerlh.inputs.subjects_dir = subjects_dir samplerrh = samplerlh.clone('sampler_rh') samplerlh.inputs.hemi = 'lh' wf.connect(collector, 'out', samplerlh, 'source_file') wf.connect(registration, 'outputspec.out_reg_file', samplerlh, 'reg_file') wf.connect(target, 'target_subject', samplerlh, 'target_subject') samplerrh.set_input('hemi', 'rh') wf.connect(collector, 'out', samplerrh, 'source_file') wf.connect(registration, 'outputspec.out_reg_file', samplerrh, 'reg_file') wf.connect(target, 'target_subject', samplerrh, 'target_subject') # Combine left and right hemisphere to text file combiner = MapNode(Function(input_names=['left', 'right'], output_names=['out_file'], function=combine_hemi, imports=imports), iterfield=['left', 'right'], name="combiner") wf.connect(samplerlh, 'out_file', combiner, 'left') wf.connect(samplerrh, 'out_file', combiner, 'right') # Sample the time series file for each subcortical roi ts2txt = MapNode(Function( input_names=['timeseries_file', 'label_file', 'indices'], output_names=['out_file'], function=extract_subrois, imports=imports), iterfield=['timeseries_file'], name='getsubcortts') ts2txt.inputs.indices = [8] + list(range(10, 14)) + [17, 18, 26, 47] +\ list(range(49, 55)) + [58] ts2txt.inputs.label_file = \ os.path.abspath(('OASIS-TRT-20_jointfusion_DKT31_CMA_labels_in_MNI152_' '2mm_v2.nii.gz')) wf.connect(maskts, 'out_file', ts2txt, 'timeseries_file') ###### substitutions = [('_target_subject_', ''), ('_filtermotart_cleaned_bp_trans_masked', ''), ('_filtermotart_cleaned_bp', '')] regex_subs = [ ('_ts_masker.*/sar', '/smooth/'), ('_ts_masker.*/ar', '/unsmooth/'), ('_combiner.*/sar', '/smooth/'), ('_combiner.*/ar', '/unsmooth/'), ('_aparc_ts.*/sar', '/smooth/'), ('_aparc_ts.*/ar', '/unsmooth/'), ('_getsubcortts.*/sar', '/smooth/'), ('_getsubcortts.*/ar', '/unsmooth/'), ('series/sar', 'series/smooth/'), ('series/ar', 'series/unsmooth/'), ('_inverse_transform./', ''), ] # Save the relevant data into an output directory datasink = Node(interface=DataSink(), name="datasink") datasink.inputs.base_directory = sink_directory datasink.inputs.container = subject_id datasink.inputs.substitutions = substitutions datasink.inputs.regexp_substitutions = regex_subs # (r'(/_.*(\d+/))', r'/run\2') wf.connect(realign, 'realignment_parameters', datasink, 'resting.qa.motion') wf.connect(art, 'norm_files', datasink, 'resting.qa.art.@norm') wf.connect(art, 'intensity_files', datasink, 'resting.qa.art.@intensity') wf.connect(art, 'outlier_files', datasink, 'resting.qa.art.@outlier_files') wf.connect(registration, 'outputspec.segmentation_files', datasink, 'resting.mask_files') wf.connect(registration, 'outputspec.anat2target', datasink, 'resting.qa.ants') wf.connect(mask, 'mask_file', datasink, 'resting.mask_files.@brainmask') wf.connect(mask_target, 'out_file', datasink, 'resting.mask_files.target') wf.connect(filter1, 'out_f', datasink, 'resting.qa.compmaps.@mc_F') wf.connect(filter1, 'out_pf', datasink, 'resting.qa.compmaps.@mc_pF') wf.connect(filter2, 'out_f', datasink, 'resting.qa.compmaps') wf.connect(filter2, 'out_pf', datasink, 'resting.qa.compmaps.@p') wf.connect(bandpass, 'out_files', datasink, 'resting.timeseries.@bandpassed') wf.connect(smooth, 'smoothed_files', datasink, 'resting.timeseries.@smoothed') wf.connect(createfilter1, 'out_files', datasink, 'resting.regress.@regressors') wf.connect(createfilter2, 'out_files', datasink, 'resting.regress.@compcorr') wf.connect(maskts, 'out_file', datasink, 'resting.timeseries.target') wf.connect(sampleaparc, 'summary_file', datasink, 'resting.parcellations.aparc') wf.connect(sampleaparc, 'avgwf_txt_file', datasink, 'resting.parcellations.aparc.@avgwf') wf.connect(ts2txt, 'out_file', datasink, 'resting.parcellations.grayo.@subcortical') datasink2 = Node(interface=DataSink(), name="datasink2") datasink2.inputs.base_directory = sink_directory datasink2.inputs.container = subject_id datasink2.inputs.substitutions = substitutions datasink2.inputs.regexp_substitutions = regex_subs # (r'(/_.*(\d+/))', r'/run\2') wf.connect(combiner, 'out_file', datasink2, 'resting.parcellations.grayo.@surface') return wf
def smoothing_skullstrip( fmriprep_dir, output_dir, work_dir, subject_list, task, run, fwhm=6.0, name="smoothing_skullstrip", ): """ FSL smooth fMRIprep output """ workflow = pe.Workflow(name=name) workflow.base_dir = work_dir template = { "bolds": "sub-{subject}/func/sub-{subject}_task-{task}_run-{run}_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz", "mask": "sub-{subject}/func/sub-{subject}_task-{task}_run-{run}_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz", } bg = pe.Node(SelectFiles(template, base_directory=fmriprep_dir), name="datagrabber") bg.iterables = [("subject", subject_list), ("task", task), ("run", run)] # Create DataSink object sinker = pe.Node(DataSink(), name="sinker") sinker.inputs.base_directory = output_dir sinker.inputs.substitutions = [ ("_run_1_subject_", "sub-"), ("_skip0", "func"), ("desc-preproc_bold_smooth_masked_roi", f"desc-preproc-fwhm{int(fwhm)}mm_bold"), ] # Smoothing susan = create_susan_smooth() susan.inputs.inputnode.fwhm = fwhm # masking the smoothed output # note: susan workflow returns a list but apply mask only accept string of path mask_results = pe.MapNode( ApplyMask(), name="mask_results", iterfield=["in_file", "mask_file"] ) # remove first five volumes skip = pe.MapNode(fsl.ExtractROI(), name="skip", iterfield=["in_file"]) skip.inputs.t_min = 5 skip.inputs.t_size = -1 workflow.connect( [ ( bg, susan, [("bolds", "inputnode.in_files"), ("mask", "inputnode.mask_file")], ), (bg, mask_results, [("mask", "mask_file")]), (susan, mask_results, [("outputnode.smoothed_files", "in_file")]), (mask_results, skip, [("out_file", "in_file")]), (skip, sinker, [("roi_file", f"func_smooth-{int(fwhm)}mm.@out_file")]), ] ) return workflow
# In[4]: templates = { 'all_skeleton': 'Waxholm_Template/*/{map_id}/All_*_skeletonised.nii.gz', 'skeleton_mask': 'Waxholm_Template/*/{map_id}/mean_FA_skeleton_mask.nii.gz', 'all_image': 'Waxholm_Template/*/{map_id}/All_{map_id}_WAX.nii.gz', 'mean_FA': 'Waxholm_Template/*/{map_id}/mean_FA.nii.gz', } selectfiles = Node(SelectFiles(templates, base_directory=experiment_dir), name="selectfiles") #----------------------------------------------------------------------------------------------------- # In[5]: datasink = Node(DataSink(), name='datasink') datasink.inputs.container = output_dir datasink.inputs.base_directory = experiment_dir substitutions = [('_map_id_', ' ')] datasink.inputs.substitutions = substitutions #----------------------------------------------------------------------------------------------------- #Design with two contrasts only design = '/home/in/aeed/TBSS/Design_TBSS.mat' contrast = '/home/in/aeed/TBSS/Design_TBSS.con' #----------------------------------------------------------------------------------------------------- #randomise on the skeletonised data
level1design = Node(fsl.Level1Design(bases={'dgamma':{'derivs': True}}, interscan_interval=TR, model_serial_correlations=True, contrasts=contrast_list), name="level1design") # creating all the other files necessary to run the model modelgen = Node(fsl.FEATModel(), name='modelgen') # then running through FEAT feat = Node(fsl.FEAT(), name="feat") # creating datasink to collect outputs datasink = Node(DataSink(base_directory=outDir), name='datasink') ## Use the following DataSink output substitutions substitutions = [('_subject_id_', 'sub-'), ('_subsession_id_', '/ses-') ] datasink.inputs.substitutions = substitutions ########### # # SETTING UP THE WORKFLOW NODES # ###########