def head_motion_correction(name='motion_correction'): workflow = Workflow(name) input_node = Node( niu.IdentityInterface(fields=['bold_file', 'raw_ref_image']), name='input') output_node = Node(niu.IdentityInterface(fields=['xforms', 'movpar_file']), name='outputnode') mcflirt = Node(fsl.MCFLIRT(save_mats=True, save_plots=True), name='mcflirt') fsl2itk = Node(MCFLIRT2ITK(), name='fsl2itk') normalize_motion = Node(NormalizeMotionParams(format='FSL'), name="normalize_motion") workflow.connect([ (input_node, mcflirt, [('raw_ref_image', 'ref_file'), ('bold_file', 'in_file')]), (input_node, fsl2itk, [('raw_ref_image', 'in_source'), ('raw_ref_image', 'in_reference')]), (mcflirt, fsl2itk, [('mat_file', 'in_files')]), (mcflirt, normalize_motion, [('par_file', 'in_file')]), (fsl2itk, output_node, [('out_file', 'xforms')]), (normalize_motion, output_node, [('out_file', 'movpar_file')]), ]) return workflow
def MCORRECTOR(): #--- 1) Import modules import nipype.pipeline.engine as pe import os os.system('clear') from glob import glob import nipype.interfaces.fsl as fsl import nipype.interfaces.utility as util #--- 2) Record intial working directory INITDIR=os.getcwd(); #--- 3) Prompt user for directory containing DICOM FILES NIFTIFILE=raw_input('Please drag in the nifti\n file you wish to motion correct\n(ensure there is no blank space at the end)\n') os.system('clear') print '---\n' NIFTIFILE=NIFTIFILE.strip('\'"') NIFTIDIR=os.path.split(NIFTIFILE)[0] #--- 3) Move to directory os.chdir(NIFTIDIR) #--- 4) Set up motion correction node motion_correct = pe.Node(interface=fsl.MCFLIRT(save_mats=True,save_plots=True,interpolation='spline'),name='MCORRECTED') motion_correct.inputs.in_file=NIFTIFILE #--- 5) Set up plotting node plot_motion = pe.Node(interface=fsl.PlotMotionParams(in_source='fsl'),name='PLOTTED') plot_motion.iterables = ('plot_type', ['rotations', 'translations']) #--- 5) Utility output node outputnode = pe.Node(interface=util.IdentityInterface(fields=['mcorrected_files']),name='outputnode') #--- 6) Set up workflow workflow = pe.Workflow(name='MCORRECTOR') workflow.base_dir = NIFTIDIR #--- 7) Connect nodes. workflow.connect(motion_correct, 'par_file', plot_motion, 'in_file') workflow.connect(motion_correct,'out_file', outputnode,'mcorrected_files') workflow.write_graph(graph2use='exec') #--- 8) Run workflow result=workflow.run() print "Node completed. Returning to intital directory\n" os.chdir(INITDIR)
def intrascan_alignment_pipeline(self, **kwargs): # inputs=[FilesetSpec('preproc', nifti_gz_format)], # outputs=[FilesetSpec('moco', nifti_gz_format), # FilesetSpec('align_mats', directory_format), # FilesetSpec('moco_par', par_format)], pipeline = self.new_pipeline(name='MCFLIRT_pipeline', desc=("Intra-epi volumes alignment."), citations=[fsl_cite], **kwargs) mcflirt = pipeline.add('mcflirt', fsl.MCFLIRT(), requirements=[fsl_req.v('5.0.9')]) mcflirt.inputs.ref_vol = 0 mcflirt.inputs.save_mats = True mcflirt.inputs.save_plots = True mcflirt.inputs.output_type = 'NIFTI_GZ' mcflirt.inputs.out_file = 'moco.nii.gz' pipeline.connect_input('preproc', mcflirt, 'in_file') pipeline.connect_output('moco', mcflirt, 'out_file') pipeline.connect_output('moco_par', mcflirt, 'par_file') merge = pipeline.add('merge', MergeListMotionMat()) pipeline.connect(mcflirt, 'mat_file', merge, 'file_list') pipeline.connect_output('align_mats', merge, 'out_dir') return pipeline
def fsl_realign_opt(name='fsl_realign_opt'): inputnode = pe.Node( utility.IdentityInterface( fields=['fmri','reference','mask']), name='inputspec') n_flirt_epi2t1 = pe.Node( fsl.FLIRT(out_matrix_file='flirt_epi2t1.mat', cost='normmi', # as in fcon1000 preproc, why?? searchr_x=[-10,10],searchr_y=[-10,10],searchr_z=[-10,10], dof=6), name='flirt_epi2t1') n_mcflirt_spline = pe.Node( fsl.MCFLIRT(interpolation='spline', ref_vol=0, save_plots=True, save_rms=True, save_mats=True, stats_imgs=True, dof=6), name='mcflirt_spline') w=pe.Workflow(name=name) w.connect([ (inputnode,n_flirt_epi2t1,[('fmri','in_file'), ('reference','reference')]), (inputnode,n_mcflirt_spline,[('fmri','in_file'),]), (n_flirt_epi2t1,n_mcflirt_spline,[('out_matrix_file','init')]) ]) return w
def intrascan_alignment_pipeline(self, **name_maps): pipeline = self.new_pipeline( name='MCFLIRT_pipeline', desc=("Intra-epi volumes alignment."), citations=[fsl_cite], name_maps=name_maps) mcflirt = pipeline.add( 'mcflirt', fsl.MCFLIRT( ref_vol=0, save_mats=True, save_plots=True, output_type='NIFTI_GZ', out_file='moco.nii.gz'), inputs={ 'in_file': ('mag_preproc', nifti_gz_format)}, outputs={ 'moco': ('out_file', nifti_gz_format), 'moco_par': ('par_file', par_format)}, requirements=[fsl_req.v('5.0.9')]) pipeline.add( 'merge', MergeListMotionMat(), inputs={ 'file_list': (mcflirt, 'mat_file')}, outputs={ 'align_mats': ('out_dir', motion_mats_format)}) return pipeline
def hmc_mcflirt(name='fMRI_HMC_mcflirt'): """ An :abbr:`HMC (head motion correction)` for functional scans using FSL MCFLIRT """ workflow = pe.Workflow(name=name) inputnode = pe.Node(niu.IdentityInterface( fields=['in_file', 'fd_radius', 'start_idx', 'stop_idx']), name='inputnode') outputnode = pe.Node(niu.IdentityInterface( fields=['out_file', 'out_fd']), name='outputnode') mcflirt = pe.Node(fsl.MCFLIRT(save_plots=True, save_rms=True, save_mats=True), name='MCFLIRT') fdnode = pe.Node(nac.FramewiseDisplacement(normalize=False), name='ComputeFD') workflow.connect([ (inputnode, mcflirt, [('in_file', 'in_file')]), (inputnode, fdnode, [('fd_radius', 'radius')]), (mcflirt, fdnode, [('par_file', 'in_plots')]), (mcflirt, outputnode, [('out_file', 'out_file')]), (fdnode, outputnode, [('out_file', 'out_fd')]), ]) return workflow
def intrascan_alignment_pipeline(self, **kwargs): pipeline = self.create_pipeline( name='MCFLIRT_pipeline', inputs=[DatasetSpec('preproc', nifti_gz_format)], outputs=[ DatasetSpec('moco', nifti_gz_format), DatasetSpec('align_mats', directory_format), DatasetSpec('moco_par', par_format) ], desc=("Intra-epi volumes alignment."), version=1, citations=[fsl_cite], **kwargs) mcflirt = pipeline.create_node(fsl.MCFLIRT(), name='mcflirt', requirements=[fsl509_req]) mcflirt.inputs.ref_vol = 0 mcflirt.inputs.save_mats = True mcflirt.inputs.save_plots = True mcflirt.inputs.output_type = 'NIFTI_GZ' mcflirt.inputs.out_file = 'moco.nii.gz' pipeline.connect_input('preproc', mcflirt, 'in_file') pipeline.connect_output('moco', mcflirt, 'out_file') pipeline.connect_output('moco_par', mcflirt, 'par_file') merge = pipeline.create_node(MergeListMotionMat(), name='merge') pipeline.connect(mcflirt, 'mat_file', merge, 'file_list') pipeline.connect_output('align_mats', merge, 'out_dir') return pipeline
def create_bet_mask_from_dwi(name, do_realignment=True): wf = Workflow(name=name) inputnode = Node(interface=IdentityInterface(fields=["dwi", "bvec", "bval"]), name="inputnode") b0s = Node(DwiextractB0(), "b0s") wf.connect(inputnode, "dwi", b0s, "in_file") wf.connect(inputnode, "bvec", b0s, "bvec") wf.connect(inputnode, "bval", b0s, "bval") meanb0 = Node(fsl.ImageMaths(op_string='-Tmean', suffix='_mean'), name="meanb0") wf.connect(b0s, "out_file", meanb0, "in_file") mcflirt = Node(fsl.MCFLIRT(), "mcflirt") bet = Node(fsl.BET(), "bet") bet.inputs.frac = 0.3 bet.inputs.robust = True bet.inputs.mask = True if do_realignment: wf.connect(meanb0, "out_file", mcflirt, "in_file") wf.connect(mcflirt, "out_file", bet, "in_file") else: wf.connect(meanb0, "out_file", bet, "in_file") outputnode = Node(interface=IdentityInterface(fields=["mask_file"]), name="outputnode") wf.connect(bet, "mask_file", outputnode, "mask_file") return wf
def _run_interface(self, runtime): in_files = self.inputs.in_files if not isinstance(in_files, list): in_files = [self.inputs.in_files] # Generate output average name early self._results['out_avg'] = fname_presuffix(self.inputs.in_files[0], suffix='_avg', newpath=runtime.cwd) if self.inputs.to_ras: in_files = [reorient(inf, newpath=runtime.cwd) for inf in in_files] if len(in_files) == 1: filenii = nb.load(in_files[0]) filedata = filenii.get_data() # magnitude files can have an extra dimension empty if filedata.ndim == 5: sqdata = np.squeeze(filedata) if sqdata.ndim == 5: raise RuntimeError('Input image (%s) is 5D' % in_files[0]) else: in_files = [ fname_presuffix(in_files[0], suffix='_squeezed', newpath=runtime.cwd) ] nb.Nifti1Image(sqdata, filenii.affine, filenii.header).to_filename(in_files[0]) if np.squeeze(nb.load(in_files[0]).get_data()).ndim < 4: self._results['out_file'] = in_files[0] self._results['out_avg'] = in_files[0] # TODO: generate identity out_mats and zero-filled out_movpar return runtime in_files = in_files[0] else: magmrg = fsl.Merge(dimension='t', in_files=self.inputs.in_files) in_files = magmrg.run().outputs.merged_file mcflirt = fsl.MCFLIRT(cost='normcorr', save_mats=True, save_plots=True, ref_vol=0, in_file=in_files) mcres = mcflirt.run() self._results['out_mats'] = mcres.outputs.mat_file self._results['out_movpar'] = mcres.outputs.par_file self._results['out_file'] = mcres.outputs.out_file hmcnii = nb.load(mcres.outputs.out_file) hmcdat = hmcnii.get_data().mean(axis=3) if self.inputs.zero_based_avg: hmcdat -= hmcdat.min() nb.Nifti1Image(hmcdat, hmcnii.affine, hmcnii.header).to_filename(self._results['out_avg']) return runtime
def create_moco_pipeline(name='motion_correction'): # initiate workflow moco = Workflow(name='motion_correction') # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # inputnode inputnode = Node(util.IdentityInterface(fields=['epi']), name='inputnode') # outputnode outputnode = Node(util.IdentityInterface(fields=[ 'epi_moco', 'par_moco', 'mat_moco', 'rms_moco', 'epi_mean', 'rotplot', 'transplot', 'dispplots', 'tsnr_file' ]), name='outputnode') # mcflirt motion correction to 1st volume mcflirt = Node(fsl.MCFLIRT(save_mats=True, save_plots=True, save_rms=True, ref_vol=1, out_file='rest_realigned.nii.gz'), name='mcflirt') # plot motion parameters rotplotter = Node(fsl.PlotMotionParams(in_source='fsl', plot_type='rotations', out_file='rotation_plot.png'), name='rotplotter') transplotter = Node(fsl.PlotMotionParams(in_source='fsl', plot_type='translations', out_file='translation_plot.png'), name='transplotter') dispplotter = MapNode(interface=fsl.PlotMotionParams( in_source='fsl', plot_type='displacement', ), name='dispplotter', iterfield=['in_file']) dispplotter.iterables = ('plot_type', ['displacement']) # calculate tmean tmean = Node(fsl.maths.MeanImage(dimension='T', out_file='rest_realigned_mean.nii.gz'), name='tmean') # calculate tsnr tsnr = Node(confounds.TSNR(), name='tsnr') # create connections moco.connect([(inputnode, mcflirt, [('epi', 'in_file')]), (mcflirt, tmean, [('out_file', 'in_file')]), (mcflirt, rotplotter, [('par_file', 'in_file')]), (mcflirt, transplotter, [('par_file', 'in_file')]), (mcflirt, dispplotter, [('rms_files', 'in_file')]), (tmean, outputnode, [('out_file', 'epi_mean')]), (mcflirt, outputnode, [('out_file', 'epi_moco'), ('par_file', 'par_moco'), ('mat_file', 'mat_moco'), ('rms_files', 'rms_moco')]), (rotplotter, outputnode, [('out_file', 'rotplot')]), (transplotter, outputnode, [('out_file', 'transplot')]), (dispplotter, outputnode, [('out_file', 'dispplots')]), (mcflirt, tsnr, [('out_file', 'in_file')]), (tsnr, outputnode, [('tsnr_file', 'tsnr_file')])]) return moco
def init_params(self, in_file: str, out_file: str): mcflt = fsl.MCFLIRT() mcflt.inputs.in_file = in_file mcflt.inputs.out_file = out_file # mcflt.inputs.save_mats = True # mcflt.inputs.save_plots = True # mcflt.inputs.save_rms = True # mcflt.inputs.stats_imgs = True return mcflt
def _run_interface(self, runtime): ref_name = self.inputs.in_file ref_nii = nb.load(ref_name) n_volumes_to_discard = _get_vols_to_discard(ref_nii) self._results["n_volumes_to_discard"] = n_volumes_to_discard out_ref_fname = os.path.join(runtime.cwd, "ref_bold.nii.gz") if isdefined(self.inputs.sbref_file): out_ref_fname = os.path.join(runtime.cwd, "ref_sbref.nii.gz") ref_name = self.inputs.sbref_file ref_nii = nb.squeeze_image(nb.load(ref_name)) # If reference is only 1 volume, return it directly if len(ref_nii.shape) == 3: ref_nii.header.extensions.clear() ref_nii.to_filename(out_ref_fname) self._results['ref_image'] = out_ref_fname return runtime else: # Reset this variable as it no longer applies # and value for the output is stored in self._results n_volumes_to_discard = 0 # Slicing may induce inconsistencies with shape-dependent values in extensions. # For now, remove all. If this turns out to be a mistake, we can select extensions # that don't break pipeline stages. ref_nii.header.extensions.clear() if n_volumes_to_discard == 0: if ref_nii.shape[-1] > 40: ref_name = os.path.join(runtime.cwd, "slice.nii.gz") nb.Nifti1Image(ref_nii.dataobj[:, :, :, 20:40], ref_nii.affine, ref_nii.header).to_filename(ref_name) if self.inputs.mc_method == "AFNI": res = afni.Volreg(in_file=ref_name, args='-Fourier -twopass', zpad=4, outputtype='NIFTI_GZ').run() elif self.inputs.mc_method == "FSL": res = fsl.MCFLIRT(in_file=ref_name, ref_vol=0, interpolation='sinc').run() mc_slice_nii = nb.load(res.outputs.out_file) median_image_data = np.median(mc_slice_nii.get_fdata(), axis=3) else: median_image_data = np.median( ref_nii.dataobj[:, :, :, :n_volumes_to_discard], axis=3) nb.Nifti1Image(median_image_data, ref_nii.affine, ref_nii.header).to_filename(out_ref_fname) self._results["ref_image"] = out_ref_fname return runtime
def motion_correct(in_file: Path, out_file: Path): """ Perform motion correction using FSL's MCFLIRT Arguments: in_file {Path} -- [4D nifti path] out_file {Path} -- [4D nifti output path] """ mcflt = fsl.MCFLIRT() mcflt.inputs.in_file = in_file mcflt.inputs.out_file = out_file return mcflt
def mcflirt(launcher, in_file, out_file): mcflt = flsi.MCFLIRT() mcflt.inputs.in_file = in_file # Low Space Resolution, High time resolution 64x64x32x150 mcflt.inputs.cost = 'mutualinfo' mcflt.inputs.out_file = out_file mcflt.inputs.save_plots = True mcflt.cmdline # 'mcflirt -in rest.nii.gz -plot -cost mutualinfo -out rest' # >>> res = mcflt.run() # doctest: +SKIP launcher.run(mcflt.cmdline)
def create_realign_flow(name='realign'): """Realign a time series to the middle volume using spline interpolation Uses MCFLIRT to realign the time series and ApplyWarp to apply the rigid body transformations using spline interpolation (unknown order). Example ------- >>> wf = create_realign_flow() >>> wf.inputs.inputspec.func = 'f3.nii' >>> wf.run() # doctest: +SKIP """ realignflow = pe.Workflow(name=name) inputnode = pe.Node(interface=util.IdentityInterface(fields=[ 'func', ]), name='inputspec') outputnode = pe.Node(interface=util.IdentityInterface( fields=['realigned_file', 'rms_files', 'par_file']), name='outputspec') start_dropper = pe.Node(util.Function( input_names=['in_vol_fn', 'n_frames'], output_names=['out_fn'], function=remove_first_n_frames), name='start_dropper') start_dropper.inputs.n_frames = 5 realigner = pe.Node(fsl.MCFLIRT(save_mats=True, stats_imgs=True, save_rms=True, save_plots=True), name='realigner') splitter = pe.Node(fsl.Split(dimension='t'), name='splitter') warper = pe.MapNode(fsl.ApplyWarp(interp='spline'), iterfield=['in_file', 'premat'], name='warper') joiner = pe.Node(fsl.Merge(dimension='t'), name='joiner') realignflow.connect(inputnode, 'func', start_dropper, 'in_vol_fn') realignflow.connect(start_dropper, 'out_fn', realigner, 'in_file') realignflow.connect(start_dropper, ('out_fn', select_volume, 'middle'), realigner, 'ref_vol') realignflow.connect(realigner, 'out_file', splitter, 'in_file') realignflow.connect(realigner, 'mat_file', warper, 'premat') realignflow.connect(realigner, 'variance_img', warper, 'ref_file') realignflow.connect(splitter, 'out_files', warper, 'in_file') realignflow.connect(warper, 'out_file', joiner, 'in_files') realignflow.connect(joiner, 'merged_file', outputnode, 'realigned_file') realignflow.connect(realigner, 'rms_files', outputnode, 'rms_files') realignflow.connect(realigner, 'par_file', outputnode, 'par_file') return realignflow
def motion(file_to_realign, ref_vol): print "running realignment" realign = fsl.MCFLIRT(interpolation='spline', ref_file=ref_vol) realign.inputs.save_plots = True realign.inputs.save_mats = True realign.inputs.mean_vol = True realign.inputs.in_file = file_to_realign realign.inputs.out_file = 'fsl_corr_' +\ os.path.split(file_to_realign)[1] Realign_res = realign.run() out_file = Realign_res.outputs.out_file par_file = Realign_res.outputs.par_file return out_file, par_file
def cbf_cl_preprocessing_initialize(): """ 1) Extracts control/label pairs from raw pCASL data 2) Motion correction with mcflirt 3) Control/Label pairwise subtraction """ cl_preproc = pe.Workflow(name='cl_preproc') cl_preproc.base_dir = (os.getcwd()) cl_inputnode = pe.Node( interface=util.IdentityInterface(fields=['func', 'm0', 'm0_mask']), name='cl_inputnode') print(cl_inputnode.inputs) cl_datasink = pe.Node(nio.DataSink(), name='cl_sinker') cl_datasink.inputs.base_directory = results_dir # Extract Control Label Pairs cl_fslroi = pe.Node(fsl.ExtractROI(roi_file='cl.nii.gz', t_min=1, t_size=-1), name='cl_fslroi') # Align Control/Label Pairs to M0 image cl_mcflirt = pe.Node(fsl.MCFLIRT(save_mats=True, save_plots=True), name='cl_mcflirt') # Mask Control Label Pairs cl_mask = pe.Node(fsl.ApplyMask(), name="cl_mask") cl_outputnode = pe.Node(interface=util.IdentityInterface( fields=['cl', 'cl_brain', 'cl_mcf', 'cl_mcf_par']), name='cl_outputnode') cl_preproc.connect([ (cl_inputnode, cl_fslroi, [('func', 'in_file')]), (cl_fslroi, cl_mcflirt, [['roi_file', 'in_file']]), (cl_inputnode, cl_mcflirt, [['m0', 'ref_file']]), (cl_mcflirt, cl_mask, [('out_file', 'in_file')]), (cl_inputnode, cl_mask, [('m0_mask', 'mask_file')]), (cl_fslroi, cl_datasink, [['roi_file', 'results.@cl']]), (cl_mcflirt, cl_datasink, [['out_file', 'results.@mcfcl']]), (cl_mask, cl_datasink, [['out_file', 'results.@cl_mask']]), (cl_fslroi, cl_outputnode, [['roi_file', 'cl']]), (cl_mcflirt, cl_outputnode, [['par_file', 'cl_mcf_par']]), (cl_mcflirt, cl_outputnode, [['out_file', 'cl_mcf']]), (cl_mask, cl_outputnode, [['out_file', 'cl_brain']]) ]) return cl_preproc
def preporcessFMRI(): global nii_file, preproc_status # skull stripping btr = fsl.BET() btr.inputs.in_file = nii_file btr.inputs.frac = 0.7 btr.inputs.out_file = nii_file btr.cmdline res = btr.run() preproc_status = 20 # segmentation and bias correction fastr = fsl.FAST() fastr.inputs.in_files = nii_file fastr.cmdline out = fastr.run() preproc_status = 40 # coregistration flt = fsl.FLIRT(bins=640, cost_func='mutualinfo') flt.inputs.in_file = nii_file flt.inputs.reference = nii_file flt.inputs.output_type = "NIFTI_GZ" preproc_status = 45 flt.cmdline preproc_status = 50 res = flt.run() preproc_status = 60 # motion correction mcflt = fsl.MCFLIRT() mcflt.inputs.in_file = nii_file mcflt.inputs.cost = 'mutualinfo' mcflt.inputs.out_file = nii_file mcflt.cmdline res = mcflt.run() preproc_status = 80 # smoothing sus = fsl.SUSAN() sus.inputs.in_file = nii_file sus.inputs.out_file = nii_file sus.inputs.brightness_threshold = 2000.0 sus.inputs.fwhm = 8.0 result = sus.run() preproc_status = 100
def _run_interface(self, runtime): if isdefined(self.inputs.sbref_file): self._results['ref_image'] = self.inputs.sbref_file return runtime in_nii = nb.load(self.inputs.in_file) data_slice = in_nii.dataobj[:, :, :, :50] # Slicing may induce inconsistencies with shape-dependent values in extensions. # For now, remove all. If this turns out to be a mistake, we can select extensions # that don't break pipeline stages. in_nii.header.extensions.clear() n_volumes_to_discard = _get_vols_to_discard(in_nii) out_ref_fname = os.path.join(runtime.cwd, "ref_image.nii.gz") if n_volumes_to_discard == 0: if in_nii.shape[-1] > 40: slice_fname = os.path.join(runtime.cwd, "slice.nii.gz") nb.Nifti1Image(data_slice[:, :, :, 20:40], in_nii.affine, in_nii.header).to_filename(slice_fname) else: slice_fname = self.inputs.in_file if self.inputs.mc_method == "AFNI": res = afni.Volreg(in_file=slice_fname, args='-Fourier -twopass', zpad=4, outputtype='NIFTI_GZ').run() elif self.inputs.mc_method == "FSL": res = fsl.MCFLIRT(in_file=slice_fname, ref_vol=0, interpolation='sinc').run() mc_slice_nii = nb.load(res.outputs.out_file) median_image_data = np.median(mc_slice_nii.get_data(), axis=3) else: median_image_data = np.median( data_slice[:, :, :, :n_volumes_to_discard], axis=3) nb.Nifti1Image(median_image_data, in_nii.affine, in_nii.header).to_filename(out_ref_fname) self._results["ref_image"] = out_ref_fname self._results["n_volumes_to_discard"] = n_volumes_to_discard return runtime
def _run_interface(self, runtime): in_nii = nb.load(self.inputs.in_file) data_slice = in_nii.dataobj[:, :, :, :50] global_signal = data_slice.mean(axis=0).mean(axis=0).mean(axis=0) n_volumes_to_discard = is_outlier(global_signal) out_ref_fname = os.path.abspath("ref_image.nii.gz") if n_volumes_to_discard == 0: if in_nii.shape[-1] > 40: slice = data_slice[:, :, :, 20:40] slice_fname = os.path.abspath("slice.nii.gz") nb.Nifti1Image(slice, in_nii.affine, in_nii.header).to_filename(slice_fname) else: slice_fname = self.inputs.in_file if self.inputs.mc_method == "AFNI": res = afni.Volreg(in_file=slice_fname, args='-Fourier -twopass', zpad=4, outputtype='NIFTI_GZ').run() elif self.inputs.mc_method == "FSL": res = fsl.MCFLIRT(in_file=slice_fname, ref_vol=0, interpolation='sinc').run() mc_slice_nii = nb.load(res.outputs.out_file) median_image_data = np.median(mc_slice_nii.get_data(), axis=3) nb.Nifti1Image(median_image_data, mc_slice_nii.affine, mc_slice_nii.header).to_filename(out_ref_fname) else: median_image_data = np.median( data_slice[:, :, :, :n_volumes_to_discard], axis=3) nb.Nifti1Image(median_image_data, in_nii.affine, in_nii.header).to_filename(out_ref_fname) self._results = dict() self._results["ref_image"] = out_ref_fname self._results["n_volumes_to_discard"] = n_volumes_to_discard return runtime
def create_realignment_workflow(name="realignment"): """Motion and slice-time correct the timeseries and summarize.""" inputnode = Node(IdentityInterface(["timeseries"]), "inputs") # Get the middle volume of each run for motion correction extractref = MapNode(ExtractRealignmentTarget(), "in_file", "extractref") # Motion correct to middle volume of each run mcflirt = MapNode( fsl.MCFLIRT(cost="normcorr", interpolation="spline", save_mats=True, save_rms=True, save_plots=True), ["in_file", "ref_file"], "mcflirt") # Generate a report on the motion correction mcreport = MapNode(RealignmentReport(), ["target_file", "realign_params", "displace_params"], "mcreport") # Define the outputs outputnode = Node( IdentityInterface( ["timeseries", "example_func", "report", "motion_file"]), "outputs") # Define and connect the sub workflow realignment = Workflow(name) realignment.connect([ (inputnode, extractref, [("timeseries", "in_file")]), (inputnode, mcflirt, [("timeseries", "in_file")]), (extractref, mcflirt, [("out_file", "ref_file")]), (extractref, mcreport, [("out_file", "target_file")]), (mcflirt, mcreport, [("par_file", "realign_params"), ("rms_files", "displace_params")]), (mcflirt, outputnode, [("out_file", "timeseries")]), (extractref, outputnode, [("out_file", "example_func")]), (mcreport, outputnode, [("realign_report", "report"), ("motion_file", "motion_file")]), ]) return realignment
def load_and_mc(infile, workdir): """ Perform motion correction on a dataset and load the result in pymvpa """ # perform motion correction using mcflirt implemented by nipype. fsl.FSLCommand.set_default_output_type('NIFTI_GZ') infilename = infile.split('/')[-1] mcfile = os.path.join(workdir, infilename.replace('.nii.gz', '_mc.nii.gz')) mcflt = fsl.MCFLIRT(in_file=infile, out_file=mcfile) mcflt.run() # load the preprocessed nifti as pymvpa data set dataset = fmri_dataset(mcfile) tr = float(dataset.sa['time_coords'][1] - dataset.sa['time_coords'][0]) nvolumes = len(dataset.samples) return dataset, tr, nvolumes
def _run_interface(self, runtime): if len(self.inputs.in_files) == 1: self._results['out_file'] = self.inputs.in_files[0] self._results['out_avg'] = self.inputs.in_files[0] # TODO: generate identity out_mats and zero-filled out_movpar return runtime magmrg = fsl.Merge(dimension='t', in_files=self.inputs.in_files) mcflirt = fsl.MCFLIRT(cost='normcorr', save_mats=True, save_plots=True, ref_vol=0, in_file=magmrg.run().outputs.merged_file) mcres = mcflirt.run() self._results['out_mats'] = mcres.outputs.mat_file self._results['out_movpar'] = mcres.outputs.par_file self._results['out_file'] = mcres.outputs.out_file mean = fsl.MeanImage(dimension='T', in_file=mcres.outputs.out_file) self._results['out_avg'] = mean.run().outputs.out_file return runtime
def hmc_mcflirt(settings, name='fMRI_HMC_mcflirt'): """ An :abbr:`HMC (head motion correction)` for functional scans using FSL MCFLIRT .. workflow:: from mriqc.workflows.functional import hmc_mcflirt wf = hmc_mcflirt({'biggest_file_size_gb': 1}) """ workflow = pe.Workflow(name=name) inputnode = pe.Node(niu.IdentityInterface( fields=['in_file', 'fd_radius', 'start_idx', 'stop_idx']), name='inputnode') outputnode = pe.Node(niu.IdentityInterface(fields=['out_file', 'out_fd']), name='outputnode') gen_ref = pe.Node(nwr.EstimateReferenceImage(mc_method="AFNI"), name="gen_ref") mcflirt = pe.Node(fsl.MCFLIRT(save_plots=True, interpolation='sinc'), name='MCFLIRT') mcflirt.interface.estimated_memory_gb = settings[ "biggest_file_size_gb"] * 2.5 fdnode = pe.Node(nac.FramewiseDisplacement(normalize=False, parameter_source="FSL"), name='ComputeFD') workflow.connect([ (inputnode, gen_ref, [('in_file', 'in_file')]), (gen_ref, mcflirt, [('ref_image', 'ref_file')]), (inputnode, mcflirt, [('in_file', 'in_file')]), (inputnode, fdnode, [('fd_radius', 'radius')]), (mcflirt, fdnode, [('par_file', 'in_file')]), (mcflirt, outputnode, [('out_file', 'out_file')]), (fdnode, outputnode, [('out_file', 'out_fd')]), ]) return workflow
def _multiple_pe_hmc(in_files, in_movpar, in_ref=None): """ This function interprets that we are dealing with a multiple PE (phase encoding) input if it finds several files in in_files. If we have several images with various PE directions, it will compute the HMC parameters between them using an embedded workflow. It just forwards the two inputs otherwise. """ import os from nipype.interfaces import fsl from nipype.interfaces import ants if len(in_files) == 1: out_file = in_files[0] out_movpar = in_movpar else: if in_ref is None: in_ref = 0 # Head motion correction fslmerge = fsl.Merge(dimension='t', in_files=in_files) hmc = fsl.MCFLIRT(ref_vol=in_ref, save_mats=True, save_plots=True) hmc.inputs.in_file = fslmerge.run().outputs.merged_file hmc_res = hmc.run() out_file = hmc_res.outputs.out_file out_movpar = hmc_res.outputs.par_file mean = fsl.MeanImage( dimension='T', in_file=out_file) inu = ants.N4BiasFieldCorrection( dimension=3, input_image=mean.run().outputs.out_file) inu_res = inu.run() out_ref = inu_res.outputs.output_image bet = fsl.BET( frac=0.6, mask=True, in_file=out_ref) out_mask = bet.run().outputs.mask_file return (out_file, out_ref, out_mask, out_movpar)
def create_between_run_align_workflow(name='between_run_align'): between_run_align = pe.Workflow(name=name) inputs = pe.Node( interface=util.IdentityInterface(fields=['in_files', 'ref_vol']), name='inputs') select_ref_vol = pe.Node(interface=util.Select(), name='select_ref_vol') #select_ref_vol.inputs.index = [ref_vol] extract_ref_vol = pe.Node(interface=nmutil.ExtractVolume(), name='extract_ref_vol') #extract_ref_vol = pe.Node(interface=fsl.ExtractROI(), name='extract_ref_vol') #extract_ref_vol.inputs.t_min = 0 #extract_ref_vol.inputs.t_size = 1 motion_correction = pe.MapNode(interface=fsl.MCFLIRT(), name='motion_correction', iterfield=['in_file']) outputs = pe.Node(interface=util.IdentityInterface(fields=['out_files']), name='outputs') between_run_align.connect(inputs, 'in_files', select_ref_vol, 'inlist') between_run_align.connect(inputs, ('ref_vol', to_list), select_ref_vol, 'index') between_run_align.connect(select_ref_vol, 'out', extract_ref_vol, 'in_file') between_run_align.connect(inputs, ('ref_vol', to_int), extract_ref_vol, 'index') between_run_align.connect(inputs, 'in_files', motion_correction, 'in_file') between_run_align.connect(extract_ref_vol, 'out_file', motion_correction, 'ref_file') between_run_align.connect(motion_correction, 'out_file', outputs, 'out_files') return between_run_align
def simulate_run(infile, workdir, lfnl=3, hfnl=.5): """ Simple simulation of 4D fmri data. Takes a given functional image, performs motion correction, computes the mean and adds autocorrelated noise to it. Parameters ---------- infile: str Path to the 4D functional image in .nifti format outfile: str Path and name of the simulated image lfnl: float Low frequency noise level. Default = 3 Hz hfnl: float High frequency noise level. Default = None. """ # perform motion correction using mcflirt implemented by nipype. fsl.FSLCommand.set_default_output_type('NIFTI_GZ') infilename = infile.split('/')[-1] mcfile = os.path.join(workdir, infilename.replace('.nii.gz', '_mc.nii.gz')) mcflt = fsl.MCFLIRT(in_file=infile, out_file=mcfile) mcflt.run() # load the preprocessed nifti as pymvpa data set ds = fmri_dataset(mcfile) # get TR from sample attributes tr = float(ds.sa['time_coords'][1] - ds.sa['time_coords'][0]) # convert to sampling rate in Hz sr = 1.0 / tr cutoff = sr / 4 # produce simulated 4D fmri data shambold = autocorrelated_noise(ds, sr, cutoff, lfnl=lfnl, hfnl=hfnl) return shambold
def hmc_mcflirt(name='fMRI_HMC_mcflirt'): """ An :abbr:`HMC (head motion correction)` for functional scans using FSL MCFLIRT """ workflow = pe.Workflow(name=name) inputnode = pe.Node(niu.IdentityInterface( fields=['in_file', 'fd_radius', 'start_idx', 'stop_idx']), name='inputnode') outputnode = pe.Node( niu.IdentityInterface(fields=['out_file', 'out_movpar']), name='outputnode') mcflirt = pe.Node(fsl.MCFLIRT(mean_vol=True, save_plots=True, save_rms=True, save_mats=True), name="MCFLIRT") workflow.connect([(inputnode, mcflirt, [('in_file', 'in_file')]), (mcflirt, outputnode, [('out_file', 'out_file'), ('par_file', 'out_movpar')])]) return workflow
def mcflirt(self,folder,in_path): """ This function for motion correction. It is dependent on the class name: func. folder : read the string, new folder's name. in_path : read the list, element: string, directory address of data. returns a list, element: string, directory address of new data. For complete details, see the fsl.MCFLIRT() documentation. <https://nipype.readthedocs.io/en/latest/interfaces.html> """ print('#################_Data_motion_correction_started_###########') preprocessing = time.time() # Check and if not make the directory if not os.path.isdir(folder): func.newfolder(folder) # Proceed the motion correction and save the data output_list = [] for i in range(len(in_path)): print(in_path[i],"motion correction started") file = in_path[i].split('/') output = folder+'/'+file[1] output_list.append(output) mcflt = fsl.MCFLIRT() mcflt.inputs.in_file = in_path[i] mcflt.inputs.cost = 'mutualinfo' mcflt.inputs.out_file = output mcflt.cmdline mcflt.run() print(output,"motion correction completed") print("computation_time :","%.2fs" %(time.time() - preprocessing)) print('#################_Data_motion_correction_completed_#########') return output_list
def init_bold_hmc_wf(mem_gb, omp_nthreads, name='bold_hmc_wf'): """ This workflow estimates the motion parameters to perform :abbr:`HMC (head motion correction)` over the input :abbr:`BOLD (blood-oxygen-level dependent)` image. .. workflow:: :graph2use: orig :simple_form: yes from fmriprep.workflows.bold import init_bold_hmc_wf wf = init_bold_hmc_wf( mem_gb=3, omp_nthreads=1) **Parameters** mem_gb : float Size of BOLD file in GB omp_nthreads : int Maximum number of threads an individual process may use name : str Name of workflow (default: ``bold_hmc_wf``) **Inputs** bold_file BOLD series NIfTI file raw_ref_image Reference image to which BOLD series is motion corrected **Outputs** xforms ITKTransform file aligning each volume to ``ref_image`` movpar_file MCFLIRT motion parameters, normalized to SPM format (X, Y, Z, Rx, Ry, Rz) """ workflow = pe.Workflow(name=name) inputnode = pe.Node( niu.IdentityInterface(fields=['bold_file', 'raw_ref_image']), name='inputnode') outputnode = pe.Node( niu.IdentityInterface(fields=['xforms', 'movpar_file']), name='outputnode') # Head motion correction (hmc) mcflirt = pe.Node(fsl.MCFLIRT(save_mats=True, save_plots=True), name='mcflirt', mem_gb=mem_gb * 3) fsl2itk = pe.Node(MCFLIRT2ITK(), name='fsl2itk', mem_gb=0.05, n_procs=omp_nthreads) normalize_motion = pe.Node(NormalizeMotionParams(format='FSL'), name="normalize_motion", mem_gb=DEFAULT_MEMORY_MIN_GB) workflow.connect([ (inputnode, mcflirt, [('raw_ref_image', 'ref_file'), ('bold_file', 'in_file')]), (inputnode, fsl2itk, [('raw_ref_image', 'in_source'), ('raw_ref_image', 'in_reference')]), (mcflirt, fsl2itk, [('mat_file', 'in_files')]), (mcflirt, normalize_motion, [('par_file', 'in_file')]), (fsl2itk, outputnode, [('out_file', 'xforms')]), (normalize_motion, outputnode, [('out_file', 'movpar_file')]), ]) return workflow