def test_normalize12_list_outputs(create_files_in_directory): filelist, outdir, cwd = create_files_in_directory norm12 = spm.Normalize12(image_to_align=filelist[0]) assert norm12._list_outputs()['normalized_image'][0].startswith('w') norm12 = spm.Normalize12(image_to_align=filelist[0], apply_to_files=filelist[1]) assert norm12._list_outputs()['normalized_files'][0].startswith('w')
def spm_warp_to_mni(wf_name="spm_warp_to_mni"): """ Run Gunzip and SPM Normalize12 to the list of files input and outputs the list of warped files. It does: - Warp each individual input image to the standard SPM template Parameters ---------- wf_name: str Name of the workflow. Nipype Inputs ------------- warp_input.in_files: list of traits.File The raw NIFTI_GZ image files Nipype outputs -------------- warp_output.warped_files: list of existing file The warped files. Returns ------- wf: nipype Workflow """ # input # check if spm_pet_preproc.do_petpvc is True in_fields = ["in_files"] out_fields = ["warped_files"] input = setup_node( IdentityInterface(fields=in_fields, mandatory_inputs=True), name="warp_input", ) gunzip = pe.MapNode(Gunzip(), name="gunzip", iterfield=['in_file']) warp = setup_node(spm.Normalize12(jobtype='estwrite', affine_regularization_type='mni'), name="normalize12", type="map", iterfield=['image_to_align']) # output output = setup_node(IdentityInterface(fields=out_fields), name="warp_output") # Create the workflow object wf = pe.Workflow(name=wf_name) wf.connect([ # inputs (input, gunzip, [("in_files", "in_file")]), (gunzip, warp, [("out_file", "image_to_align")]), # output (warp, output, [("normalized_image", "warped_files")]), ]) return wf
def __init__(self, **template_dict): self.node = pe.Node(interface=spm.Normalize12(), name='normalize') self.node.inputs.tpm = template_dict['tpm_path'] self.node.inputs.affine_regularization_type = template_dict[ 'normalize_affine_regularization_type'] self.node.inputs.write_bounding_box = template_dict[ 'normalize_write_bounding_box'] self.node.inputs.write_interp = template_dict['normalize_write_interp'] self.node.inputs.write_voxel_sizes = template_dict[ 'normalize_write_voxel_sizes']
def spm_apply_deformations(in_file=traits.Undefined, trans_field=traits.Undefined, bbox=traits.Undefined, voxel_sizes=None): """Return a Normalize12 interface object. SPM12's new Normalise routine for warping an image to a template. For more info: http://www.mit.edu/~satra/nipype-nightly/interfaces/generated/nipype.interfaces.spm.preprocess.html#normalize12 Parameters ---------- in_file: file trans_field: file file y_*.nii containing 3 deformation fields for the deformation in x, y and z dimension bbox: (a list of from 2 to 2 items which are a list of from 3 to 3 items which are a float) write_bounding_box option. 3x2-element list of lists representing the bounding box (in mm) to be written See the preproc.get_bounding_box function. This is important to set when applying deformation fields to cropped images. voxel_sizes: list of 3 ints or floats Default: [1, 1, 1] Nipype Ouputs ------------- deformation_field: (a list of items which are an existing file name) NIfTI file containing 3 deformation fields for the deformation in x, y and z dimension normalized_files: (a list of items which are an existing file name) Normalized other files normalized_image: (a list of items which are an existing file name) Normalized file that needed to be aligned """ if voxel_sizes is None: voxel_sizes = [1, 1, 1] norm12 = spm.Normalize12(jobtype='write') norm12.inputs.deformation_file = trans_field norm12.inputs.image_to_align = in_file norm12.inputs.write_voxel_sizes = voxel_sizes norm12.inputs.write_bounding_box = bbox #norm12.run() return norm12
def process_subject(func_fname, anat_fname): # Drop dummy volumes img = nib.load(func_fname) dropped_img = nib.Nifti1Image(img.get_data()[..., n_dummies:], img.affine, img.header) fixed_fname = prefix_path('f', degz(func_fname)) nib.save(dropped_img, fixed_fname) # Ungz anatomical if anat_fname.endswith('.gz'): anat_img = nib.load(anat_fname) anat_fname = degz(anat_fname) nib.save(anat_img, anat_fname) # Slice time correction num_slices = img.shape[2] time_for_one_slice = TR / num_slices TA = TR - time_for_one_slice st = spm.SliceTiming() st.inputs.in_files = fixed_fname st.inputs.num_slices = num_slices st.inputs.time_repetition = TR st.inputs.time_acquisition = TA st.inputs.slice_order = order_func(num_slices) st.inputs.ref_slice = ref_slice st.run() fixed_stimed = prefix_path('a', fixed_fname) # Realign realign = spm.Realign() realign.inputs.in_files = fixed_stimed # Do not write resliced files, do write mean image realign.inputs.write_which = write_which realign.run() # Coregistration coreg = spm.Coregister() # Coregister structural to mean image from realignment coreg.inputs.target = prefix_path('mean', fixed_stimed) coreg.inputs.source = anat_fname coreg.run() # Normalization / resampling with normalization + realign params seg_norm = spm.Normalize12() seg_norm.inputs.image_to_align = anat_fname seg_norm.inputs.apply_to_files = fixed_stimed seg_norm.inputs.write_bounding_box = bounding_box seg_norm.inputs.write_voxel_sizes = voxel_sizes seg_norm.run()
def spm_normalize(in_file=traits.Undefined, template=None, **kwargs): """Return a Normalize12 interface object. SPM12's new Normalise routine for warping an image to a template. Parameters ---------- in_file: file template: file Template in form of tissue probablitiy maps to normalize to mutually_exclusive: deformation_file. Default: the SPM TPM file. Nipype Ouputs ------------- deformation_field: (a list of items which are an existing file name) NIfTI file containing 3 deformation fields for the deformation in x, y and z dimension normalized_files: (a list of items which are an existing file name) Normalized other files normalized_image: (a list of items which are an existing file name) Normalized file that needed to be aligned Raises ------ FileNotFoundError If `template` is `None` and can't find the TPM.nii file from SPM. Notes ----- For more info: http://www.mit.edu/~satra/nipype-nightly/interfaces/generated/nipype.interfaces.spm.preprocess.html#normalize12 """ if template is None: template = spm_tpm_priors_path() norm12 = spm.Normalize12(jobtype='estwrite', tpm=template, **kwargs) if isdefined(in_file): norm12.inputs.image_to_align = in_file #norm12.run() return norm12
def analysis_steps(self): self.analysis = type('', (), {})() # Get files subj_list = [ subj.split('_')[:-1] for subj in next(os.walk(self.proj_dir))[1] ] # TODO limit the subj_list to those without sw processed files. # for parallelization by subject, use idnetityInterface self.analysis.infosource = Node( IdentityInterface(fields=['subj_id', 'task']), name="infosource") self.analysis.infosource.iterables = [('subject_id', subj_list), ('task', self.task_names)] templates = { 'anat': '{subj_id}/t1/{subj_id}_t1*.nii', 'func': '{subj_id}/{task}*/{subj_id}_{task}*.nii' } self.analysis.sf = Node(SelectFiles(templates), name='selectfiles') self.analysis.sf.inputs.base_directory = self.proj_dir # Realign self.analysis.realign = Node(spm.Realign(register_to_mean=True, fwhm=self.opts.fwhm), name='realign') # Coregister self.analysis.coreg = Node(spm.Coregister(), name='coregistration') # Normalize self.analysis.norm12 = Node(spm.Normalize12( bias_regularization=1e-05, affine_regularization_type='mni'), name='normalize') #Smooth self.analysis.smooth = Node(spm.Smooth(), name='smooth') #smooth.inputs.in_files = 'functional.nii' self.analysis.smooth.inputs.fwhm = self.opts.smooth_fwhm
def test_normalize12(): assert spm.Normalize12._jobtype == 'spatial' assert spm.Normalize12._jobname == 'normalise' assert spm.Normalize12().inputs.jobtype == 'estwrite'
art = Node(interface=ra.ArtifactDetect(), name='art') art.inputs.norm_threshold = 1 art.inputs.zintensity_threshold = 5 art.inputs.mask_type = 'spm_global' art.inputs.parameter_source = 'SPM' art.inputs.use_differences = [ True, False ] # Reflects use difference for motion, not intensity art.inputs.use_norm = True # SPM Coregister (Estimate Only) coreg = Node(interface=spm.Coregister(), name="coregister") coreg.inputs.jobtype = 'estimate' # SPM Normalise (Estimate & Reslice) norm12 = Node(interface=spm.Normalize12(), name="normalize") #spm.Normalize12().input_spec.gm_output_type = [True, False, False] # Should be modulated normalised # Smooth smooth = Node(interface=spm.Smooth(), name="smooth") fwhmlist = [8] smooth.iterables = ( 'fwhm', fwhmlist ) # Iterables seem to follow the convention of variable.input[key] = value of the iterable. # ## Set up the file management through ds to be able to wipe out unnecessary files? # - There are all sorts of files labelled under the type of processing that produced them in each subject's folder, so I am unclear why this is a useful management step. It simply adds a "ds" folder next to the processing folders. # Collect key output files in a useful place ds = Node(interface=DataSink(), name="ds") ds.inputs.base_directory = op.abspath(output_dir)
def build_core_nodes(self): """Build and connect the core nodes of the pipelines. """ import fmri_preprocessing_workflows as utils import nipype.interfaces.utility as nutil import nipype.interfaces.spm as spm import nipype.pipeline.engine as npe from clinica.utils.filemanip import zip_nii, unzip_nii # Zipping # ======= unzip_node = npe.MapNode(name='Unzipping', iterfield=['in_file'], interface=nutil.Function( input_names=['in_file'], output_names=['out_file'], function=unzip_nii)) unzip_T1w = unzip_node.clone('UnzippingT1w') unzip_phasediff = unzip_node.clone('UnzippingPhasediff') unzip_bold = unzip_node.clone('UnzippingBold') unzip_magnitude1 = unzip_node.clone('UnzippingMagnitude1') # FieldMap calculation # ==================== if self.parameters['unwarping']: fm_node = npe.MapNode(name="FieldMapCalculation", iterfield=[ 'phase', 'magnitude', 'epi', 'et', 'blipdir', 'tert' ], interface=spm.FieldMap()) # Slice timing correction # ======================= st_node = npe.MapNode(name="SliceTimingCorrection", iterfield=[ 'in_files', 'time_repetition', 'slice_order', 'num_slices', 'ref_slice', 'time_acquisition' ], interface=spm.SliceTiming()) # Motion correction and unwarping # =============================== if self.parameters['unwarping']: mc_node = npe.MapNode(name="MotionCorrectionUnwarping", iterfield=["scans", "pmscan"], interface=spm.RealignUnwarp()) mc_node.inputs.register_to_mean = True mc_node.inputs.reslice_mask = False else: mc_node = npe.MapNode(name="MotionCorrection", iterfield=["in_files"], interface=spm.Realign()) mc_node.inputs.register_to_mean = True # Brain extraction # ================ import os.path as path from nipype.interfaces.freesurfer import MRIConvert if self.parameters['freesurfer_brain_mask']: brain_masks = [ path.join(self.caps_directory, 'subjects', self.subjects[i], self.sessions[i], 't1/freesurfer_cross_sectional', self.subjects[i] + '_' + self.sessions[i], 'mri/brain.mgz') for i in range(len(self.subjects)) ] conv_brain_masks = [ str(self.subjects[i] + '_' + self.sessions[i] + '.nii') for i in range(len(self.subjects)) ] bet_node = npe.MapNode(interface=MRIConvert(), iterfield=["in_file", "out_file"], name="BrainConversion") bet_node.inputs.in_file = brain_masks bet_node.inputs.out_file = conv_brain_masks bet_node.inputs.out_type = 'nii' else: bet_node = utils.BrainExtractionWorkflow(name="BrainExtraction") # Registration # ============ reg_node = npe.MapNode( interface=spm.Coregister(), iterfield=["apply_to_files", "source", "target"], name="Registration") # Normalization # ============= norm_node = npe.MapNode(interface=spm.Normalize12(), iterfield=['image_to_align', 'apply_to_files'], name='Normalization') # Smoothing # ========= smooth_node = npe.MapNode(interface=spm.Smooth(), iterfield=['in_files'], name='Smoothing') smooth_node.inputs.fwhm = self.parameters['full_width_at_half_maximum'] # Zipping # ======= zip_node = npe.MapNode(name='Zipping', iterfield=['in_file'], interface=nutil.Function( input_names=['in_file'], output_names=['out_file'], function=zip_nii)) zip_bet_node = zip_node.clone('ZippingBET') zip_mc_node = zip_node.clone('ZippingMC') zip_reg_node = zip_node.clone('ZippingRegistration') zip_norm_node = zip_node.clone('ZippingNormalization') zip_smooth_node = zip_node.clone('ZippingSmoothing') # Connections # =========== if self.parameters['freesurfer_brain_mask']: self.connect([ # Brain extraction (bet_node, reg_node, [('out_file', 'target')]), (bet_node, zip_bet_node, [('out_file', 'in_file')]), ]) else: self.connect([ # Brain extraction (unzip_T1w, bet_node, [('out_file', 'Segmentation.data')]), (unzip_T1w, bet_node, [('out_file', 'ApplyMask.in_file')]), (bet_node, reg_node, [('ApplyMask.out_file', 'target')]), (bet_node, zip_bet_node, [('Fill.out_file', 'in_file')]), ]) if self.parameters['unwarping']: self.connect([ # FieldMap calculation (self.input_node, fm_node, [('et', 'et')]), (self.input_node, fm_node, [('blipdir', 'blipdir')]), (self.input_node, fm_node, [('tert', 'tert')]), (self.input_node, unzip_phasediff, [('phasediff', 'in_file')]), (self.input_node, unzip_magnitude1, [('magnitude1', 'in_file') ]), (unzip_magnitude1, fm_node, [('out_file', 'magnitude')]), (unzip_phasediff, fm_node, [('out_file', 'phase')]), (unzip_bold, fm_node, [('out_file', 'epi')]), # Motion correction and unwarping (st_node, mc_node, [('timecorrected_files', 'scans')]), (fm_node, mc_node, [('vdm', 'pmscan')]), (mc_node, reg_node, [('realigned_unwarped_files', 'apply_to_files')]), (mc_node, zip_mc_node, [('realigned_unwarped_files', 'in_file') ]), ]) else: self.connect([ # Motion correction and unwarping (st_node, mc_node, [('timecorrected_files', 'in_files')]), (mc_node, reg_node, [('realigned_files', 'apply_to_files')]), (mc_node, zip_mc_node, [('realigned_files', 'in_file')]), ]) self.connect([ # Unzipping (self.input_node, unzip_T1w, [('T1w', 'in_file')]), (self.input_node, unzip_bold, [('bold', 'in_file')]), # Slice timing correction (unzip_bold, st_node, [('out_file', 'in_files')]), (self.input_node, st_node, [('time_repetition', 'time_repetition') ]), (self.input_node, st_node, [('num_slices', 'num_slices')]), (self.input_node, st_node, [('slice_order', 'slice_order')]), (self.input_node, st_node, [('ref_slice', 'ref_slice')]), (self.input_node, st_node, [('time_acquisition', 'time_acquisition')]), # Registration (mc_node, reg_node, [('mean_image', 'source')]), # Normalization (unzip_T1w, norm_node, [('out_file', 'image_to_align')]), (reg_node, norm_node, [('coregistered_files', 'apply_to_files')]), # Smoothing (norm_node, smooth_node, [('normalized_files', 'in_files')]), # Zipping (reg_node, zip_reg_node, [('coregistered_files', 'in_file')]), (norm_node, zip_norm_node, [('normalized_files', 'in_file')]), (smooth_node, zip_smooth_node, [('smoothed_files', 'in_file')]), # Returning output (zip_bet_node, self.output_node, [('out_file', 't1_brain_mask')]), (mc_node, self.output_node, [('realignment_parameters', 'mc_params')]), (zip_mc_node, self.output_node, [('out_file', 'native_fmri')]), (zip_reg_node, self.output_node, [('out_file', 't1_fmri')]), (zip_norm_node, self.output_node, [('out_file', 'mni_fmri')]), (zip_smooth_node, self.output_node, [('out_file', 'mni_smoothed_fmri')]), ])
# Start at the slice-time corrected image base_fname = 'afds114_sub009_t2r1.nii' structural_fname = 'ds114_sub009_highres.nii' # Realign realign = spm.Realign() realign.inputs.in_files = base_fname # Do not write resliced files, do write mean image realign.inputs.write_which = [0, 1] realign.run() # Coregistration coreg = spm.Coregister() # Coregister structural to mean image from realignment coreg.inputs.target = 'mean' + base_fname coreg.inputs.source = structural_fname coreg.run() # Normalization / resampling with normalization + realign params seg_norm = spm.Normalize12() seg_norm.inputs.image_to_align = structural_fname seg_norm.inputs.apply_to_files = base_fname seg_norm.run() # Smoothing smooth = spm.Smooth() smooth.inputs.in_files = 'w' + base_fname smooth.inputs.fwhm = [8, 8, 8] smooth.run()
# if the directory doesn't exist, create it if not os.path.exists(outDir): os.makedirs(outDir) # # T1 Normalization nodes # # gunzip node gunzip_T1w = Node(Gunzip(in_file=imageT1), name="gunzip_T1w") # Segmentation, native space segNative = Node(spm.NewSegment(), name='segNative') # Normalize - normalizes structural images to the MNI template normalizeT1 = Node(spm.Normalize12(jobtype='estwrite', tpm=fTPM, write_bounding_box=[[-90, -120, -70], [90, 90, 105]]), name="normalizeT1") # Segmentation, template space segMNI = Node(spm.NewSegment(), name='segMNI') # # fMRI pre-processing # # skip dummy scans extract = Node( fsl.ExtractROI( in_file=imagefMRI, # input image t_min=4, # first 4 volumes are deleted t_size=-1,
def test_normalize12(): yield assert_equal, spm.Normalize12._jobtype, 'spatial' yield assert_equal, spm.Normalize12._jobname, 'normalise' yield assert_equal, spm.Normalize12().inputs.jobtype, 'estwrite'
def __init__(self, subject, func_source, struct_source, datasink, TR, num_slices, dim=2): self.subject = subject # specify input and output nodes self.func_source = func_source self.struct_source = struct_source self.datasink = datasink self.TR = TR self.num_slices = num_slices # specify nodes # structual process self.bet_struct = pe.Node(interface=fsl.BET(), name='non_brain_removal_BET_struct') self.bet_struct.inputs.output_type = "NIFTI" self.bet_struct.inputs.frac = 0.3 self.coregister_struct = pe.Node(interface=spm.Coregister(), name="coregister_struct_to_mni") self.coregister_struct.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_2mm_brain.nii' if dim == 1: self.coregister_struct.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_1mm_brain.nii' self.coregister_struct.inputs.write_interp = 7 self.coregister_struct.inputs.separation = [1.0, 1.0] self.coregister_struct.inputs.jobtype = 'estwrite' self.segment_struct = pe.Node(interface=spm.Segment(), name="segment_struct") # self.segment_struct.inputs.affine_regularization = 'mni' self.segment_struct.inputs.csf_output_type = [True, True, True] self.segment_struct.inputs.gm_output_type = [True, True, True] self.segment_struct.inputs.wm_output_type = [True, True, True] self.normalize_struct = pe.Node(interface=spm.Normalize(), name='normalize_struct') self.normalize_struct.inputs.jobtype = 'write' self.normalize_struct.inputs.write_bounding_box = [[-90, -126, -72], [90, 90, 108] ] # 91, 109, 91 if dim == 1: self.normalize_struct.inputs.write_bounding_box = [[ -91, -126, -72 ], [90, 91, 109]] # 182, 218, 182 self.normalize_struct.inputs.write_voxel_sizes = [1, 1, 1] self.normalize_gm = pe.Node(interface=spm.Normalize(), name='normalize_gm') self.normalize_gm.inputs.jobtype = 'write' self.normalize_gm.inputs.write_bounding_box = [[-90, -126, -72], [90, 90, 108]] # 91, 109, 91 if dim == 1: self.normalize_gm.inputs.write_bounding_box = [[-91, -126, -72], [90, 91, 109] ] # 182, 218, 182 self.normalize_gm.inputs.write_voxel_sizes = [1, 1, 1] self.normalize_wm = pe.Node(interface=spm.Normalize(), name='normalize_wm') self.normalize_wm.inputs.jobtype = 'write' self.normalize_wm.inputs.write_bounding_box = [[-90, -126, -72], [90, 90, 108]] # 91, 109, 91 if dim == 1: self.normalize_wm.inputs.write_bounding_box = [[-91, -126, -72], [90, 91, 109] ] # 182, 218, 182 self.normalize_wm.inputs.write_voxel_sizes = [1, 1, 1] self.normalize_csf = pe.Node(interface=spm.Normalize(), name='normalize_csf') self.normalize_csf.inputs.jobtype = 'write' self.normalize_csf.inputs.write_bounding_box = [[-90, -126, -72], [90, 90, 108]] # 91, 109, 91 if dim == 1: self.normalize_csf.inputs.write_bounding_box = [[-91, -126, -72], [90, 91, 109] ] # 182, 218, 182 self.normalize_csf.inputs.write_voxel_sizes = [1, 1, 1] ################################################################################################### # functional process self.fslsplit = pe.Node(interface=fsl.Split(), name='fslsplit') self.fslsplit.inputs.dimension = 't' self.fslsplit.inputs.output_type = "NIFTI" self.fslmerge = pe.Node(interface=fsl.Merge(), name='fslmerge') self.fslmerge.inputs.dimension = 't' self.fslmerge.inputs.output_type = "NIFTI" # helper function(s) def bet_each(in_files, subject_name): ''' @param in_files: list of image files @return out_files: list of image files after applied fsl.BET on it ''' from nipype.interfaces import fsl import nipype.pipeline.engine as pe out_files = list() step_no = 0 for file_ in in_files: bet = pe.Node(interface=fsl.BET(), name='BET_for_step_{}_{}'.format( step_no, subject_name)) bet.inputs.in_file = file_ bet.inputs.out_file = file_[:len(file_) - 4] + '_bet.nii' bet.inputs.output_type = "NIFTI" bet.inputs.frac = 0.5 bet.run() out_files.append(bet.inputs.out_file) step_no += 1 return out_files # bet_func return a list of NIFITI files self.bet_func = pe.Node(interface=Function( input_names=['in_files', 'subject_name'], output_names=['out_files'], function=bet_each), name='non_brain_removal_BET_func') self.bet_func.inputs.subject_name = self.subject self.realign = pe.Node(interface=spm.Realign(), name='realign_motion_correction') self.realign.inputs.register_to_mean = True self.coregister_func = pe.Node(interface=spm.Coregister(), name="coregister_func_to_mni") self.coregister_func.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_2mm_brain.nii' self.coregister_func.inputs.write_interp = 7 self.coregister_func.inputs.separation = [1.0, 1.0] self.coregister_func.inputs.jobtype = 'estwrite' self.segment = pe.Node(interface=spm.Segment(), name="segment") self.normalize_func = pe.Node(interface=spm.Normalize(), name="normalize_func") self.normalize_func.inputs.jobtype = 'write' self.normalize_func.inputs.write_bounding_box = [[-90, -126, -72], [90, 90, 108]] # 91, 109, 91 self.smooth = pe.Node(interface=spm.Smooth(), name="smooth") self.smooth.inputs.fwhm = [8, 8, 8] # backup node(s) self.slice_timing = pe.Node(interface=spm.SliceTiming(), name='time_slice_correction') self.slice_timing.inputs.time_repetition = self.TR self.slice_timing.inputs.num_slices = self.num_slices self.slice_timing.inputs.time_acquisition = self.TR - (self.TR / self.num_slices) self.slice_timing.inputs.slice_order = list( range(self.num_slices, 0, -1)) self.slice_timing.inputs.ref_slice = 1 self.direct_normalize = pe.Node(interface=spm.Normalize12(), name='direct_normalize') self.direct_normalize.inputs.image_to_align = 'images/MNI152_T1_2mm_brain.nii' self.direct_normalize.inputs.affine_regularization_type = 'size' # specify workflow instance self.workflow = pe.Workflow(name='preprocess_workflow') # connect nodes self.workflow.connect([ (self.struct_source, self.bet_struct, [('outfiles', 'in_file')]), (self.bet_struct, self.coregister_struct, [('out_file', 'source') ]), (self.coregister_struct, self.segment_struct, [('coregistered_source', 'data')]), (self.segment_struct, self.normalize_struct, [('transformation_mat', 'parameter_file')]), (self.coregister_struct, self.normalize_struct, [('coregistered_source', 'apply_to_files')]), (self.segment_struct, self.normalize_gm, [('transformation_mat', 'parameter_file')]), (self.segment_struct, self.normalize_gm, [('native_gm_image', 'apply_to_files')]), (self.segment_struct, self.normalize_wm, [('transformation_mat', 'parameter_file')]), (self.segment_struct, self.normalize_wm, [('native_wm_image', 'apply_to_files')]), (self.segment_struct, self.normalize_csf, [('transformation_mat', 'parameter_file')]), (self.segment_struct, self.normalize_csf, [('native_csf_image', 'apply_to_files')]), (self.func_source, self.fslsplit, [('outfiles', 'in_file')]), (self.fslsplit, self.bet_func, [('out_files', 'in_files')]), (self.bet_func, self.fslmerge, [('out_files', 'in_files')]), (self.fslmerge, self.realign, [('merged_file', 'in_files')]), (self.realign, self.datasink, [('realignment_parameters', 'realignment_parameters')]), (self.realign, self.coregister_func, [('mean_image', 'source')]), (self.realign, self.coregister_func, [('realigned_files', 'apply_to_files')]), (self.coregister_func, self.segment, [('coregistered_source', 'data')]), (self.segment, self.normalize_func, [('transformation_mat', 'parameter_file')]), (self.coregister_func, self.normalize_func, [('coregistered_files', 'apply_to_files')]), (self.normalize_func, self.smooth, [('normalized_files', 'in_files')]), # end (self.normalize_func, self.datasink, [('normalized_files', 'before_smooth')]), (self.smooth, self.datasink, [('smoothed_files', 'final_out')]), (self.normalize_struct, self.datasink, [('normalized_files', 'standardized_struct_file')]), # (self.segment_struct, self.datasink, [('native_csf_image', 'csf'), ('native_gm_image', 'grey_matter'), ('native_wm_image', 'white_matter')]) (self.normalize_gm, self.datasink, [('normalized_files', 'grey_matter')]), (self.normalize_wm, self.datasink, [('normalized_files', 'white_matter')]), (self.normalize_csf, self.datasink, [('normalized_files', 'csf')]), ]) # backup workflow(s) self.workflow_only_fmri = pe.Workflow(name='preprocess_workflow') # connect nodes self.workflow_only_fmri.connect([ (self.func_source, self.fslsplit, [('outfiles', 'in_file')]), (self.fslsplit, self.bet_func, [('out_files', 'in_files')]), (self.bet_func, self.fslmerge, [('out_files', 'in_files')]), (self.fslmerge, self.realign, [('merged_file', 'in_files')]), (self.realign, self.direct_normalize, [('realigned_files', 'apply_to_files')]), (self.direct_normalize, self.smooth, [('normalized_files', 'in_files')]), # end (self.direct_normalize, self.datasink, [('normalized_files', 'before_smooth')]), (self.smooth, self.datasink, [('smoothed_files', 'final_out')]) ])
def test_normalize12(): assert spm.Normalize12._jobtype == "spatial" assert spm.Normalize12._jobname == "normalise" assert spm.Normalize12().inputs.jobtype == "estwrite"