示例#1
0
def create_mni2diff_transforms(bedpostx_dir):
    import nipype.interfaces.fsl as fsl
    import nipype.pipeline.engine as pe
    ####Custom inputs####
    try:
        FSLDIR = os.environ['FSLDIR']
    except NameError:
        print('FSLDIR environment variable not set!')
    merged_f_samples_path = bedpostx_dir + '/merged_f1samples.nii.gz'
    ####Custom inputs####
    print('\nCreating MNI-diffusion space transforms...\n')
    input_MNI = FSLDIR + '/data/standard/MNI152_T1_1mm_brain.nii.gz'
    out_aff = bedpostx_dir + '/xfms/MNI2diff_affine.nii.gz'

    ##Create transform matrix between diff and MNI using FLIRT
    flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                    name='coregister')
    flirt.inputs.reference = merged_f_samples_path
    flirt.inputs.in_file = input_MNI
    flirt.inputs.out_matrix_file = bedpostx_dir + '/xfms/MNI2diff.mat'
    flirt.inputs.out_file = '/tmp/out_flirt.nii.gz'
    flirt.run()

    ##Apply transform between diff and MNI using FLIRT
    flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                    name='coregister')
    flirt.inputs.reference = merged_f_samples_path
    flirt.inputs.in_file = input_MNI
    flirt.inputs.apply_xfm = True
    flirt.inputs.in_matrix_file = bedpostx_dir + '/xfms/MNI2diff.mat'
    flirt.inputs.out_file = out_aff
    flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
    flirt.run()
    return out_aff
示例#2
0
def _apply_coregistration(item, reference_item, input_dir, tmp_dir, output_dir):
    """Coregisters all items to the reference item. The reference item is skipped in the list of items.

    Args:
        item (str): the items base_name to register to the reference item
        reference_item (str): the name of the reference item in the items list
        input_dir (str): the input directory in which the items reside
        tmp_dir (str): the working dir. Outputs reference volume and reference matrix
    """
    reference_mean_b0 = os.path.join(tmp_dir, reference_item + '_mask.nii.gz')
    reference_dwi = os.path.join(input_dir, reference_item + '.nii.gz')

    input_mean_b0 = os.path.join(tmp_dir, item + '_mask.nii.gz')
    input_dwi = os.path.join(input_dir, item + '.nii.gz')

    out_b0_vol = os.path.join(tmp_dir, item + '_to_' + reference_item + '_mean_b0.nii.gz')
    out_img = os.path.join(output_dir, item + '.nii.gz')
    out_mat = os.path.join(tmp_dir, item + '_to_' + reference_item + '_mean_b0.mat')

    flirt_b0 = pe.Node(fsl.FLIRT(in_file=input_mean_b0, reference=reference_mean_b0,
                                 out_file=out_b0_vol, out_matrix_file=out_mat, dof=6),
                       name='flirt_b0')
    flirt_b0.run()

    flirt_apply = pe.Node(fsl.FLIRT(in_file=input_dwi, reference=reference_dwi,
                                    out_file=out_img, in_matrix_file=out_mat,
                                    apply_xfm=True),
                          name='flirt')
    flirt_apply.run()
示例#3
0
文件: fmri.py 项目: bpinsard/misc
def epi_normalize(name='epi_normalize'):

    inputnode = pe.Node(
        utility.IdentityInterface(
            fields=['fmri_mean','t1','t1_to_mni','t1_mask']),
        name='inputspec')
    outputnode = pe.Node(
        utility.IdentityInterface(
            fields=['epi2t1_warp','coregistered_fmri_mean','epi2mni_warp',
                    't1_to_epi_warp','epi_mask']),
        name='outputspec')

    n_spm_coregister = pe.Node(
        spm.Coregister(jobtype='estimate'),
        name='spm_coregister')

#    n_epi2mni = pe.Node(
#        spm.preprocess.ApplyDeformations(
#            reference_volume='/coconut/applis/src/spm8_x64/toolbox/Seg/TPM.nii'),
#        name='epi2mni')


    n_flirt_epi2t1 = pe.Node(
        fsl.FLIRT(out_matrix_file='flirt_epi2t1.mat',
                  out_file='%s_flirt',
                  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_t1_to_epi = pe.Node(
        fsl.ConvertXFM(invert_xfm=True),
        name='t1_to_epi')

    n_mask_to_epi = pe.Node(
        fsl.FLIRT(interp='nearestneighbour',
                  out_file='%s_epi',
                  apply_xfm=True,),
        name='mask_to_epi')
    
    w=pe.Workflow(name=name)

    w.connect([
#        (inputnode,n_spm_coregister,[('fmri_mean','source'),
#                                     ('t1','target')]),
        (inputnode,n_flirt_epi2t1,[('t1','reference')]),
#        (n_spm_coregister,n_epi2mni,[('coregistered_source','in_files')]),
#        (inputnode,n_epi2mni,[('t1_to_mni','deformation_field')]),
        (inputnode,n_flirt_epi2t1,[('fmri_mean','in_file')]),
        (n_flirt_epi2t1,outputnode,[('out_matrix_file','epi2t1_warp')]),
        (n_flirt_epi2t1,n_t1_to_epi,[('out_matrix_file','in_file')]),
        (n_t1_to_epi,outputnode,[('out_file','t1_to_epi_warp')]),

        (inputnode,n_mask_to_epi,[('fmri_mean','reference'),
                                  ('t1_mask','in_file')]),
        (n_t1_to_epi, n_mask_to_epi,[('out_file','in_matrix_file')]),
        (n_mask_to_epi, outputnode, [('out_file','epi_mask')])
#        (n_spm_coregister,outputnode,[('coregistered_source',
#                                       'coregistered_fmri_mean')]),
        ])
    return w
示例#4
0
    def build_nodes(self):
        # BET - Skullstrip anatomical Image
        self.bet_anat = Node(fsl.BET(frac=0.5,
                                     robust=True,
                                     output_type='NIFTI_GZ'),
                             name="bet_anat")
        # image segmentation
        self.segmentation = Node(fsl.FAST(output_type='NIFTI_GZ'), name='segmentation')

        # threshold WM probability image
        self.threshold = Node(fsl.Threshold(thresh=0.5,
                                            args='-bin',
                                            output_type='NIFTI_GZ'),
                              name='threshold')

        # flirt - pre-alignment of images
        self.coreg_pre = Node(fsl.FLIRT(dof=6, output_type='NIFTI_GZ'), name='coreg_pre')
        # co-reg
        self.coreg_mi = Node(fsl.FLIRT(bins=640, cost_func='bbr', interp='spline', searchr_x=[-180, 180],
                                        searchr_y=[-180, 180], searchr_z=[-180, 180], dof=6, output_type='NIFTI_GZ'),
                              name='coreg_mi')

        # apply warp map to images
        self.applywarp = Node(fsl.preprocess.ApplyXFM(apply_xfm=True,
                                                      output_type='NIFTI_GZ'),
                              name='applywarp')

        # Apply coregistration warp to mean file
        self.applywarp_mean = Node(fsl.FLIRT(interp='spline',output_type='NIFTI_GZ'), name="applywarp_mean")
def quick_transform(c):
    import nipype.pipeline.engine as pe
    import nipype.interfaces.io as nio
    import nipype.interfaces.fsl as fsl

    wf = pe.Workflow(name='flirt_transform')
    sink = pe.Node(nio.DataSink(),name='sinker')
    sink.inputs.base_directory = c.sink_dir

    if c.create_transform:
        datagrabber = c.datagrabber_create.create_dataflow()
        infosource = datagrabber.get_node('subject_id_iterable')
        xform = pe.MapNode(fsl.FLIRT(interp=c.interpolation),name='flirt',iterfield=['in_file'])
        wf.connect(xform,'out_matrix_file',sink,'%s.@outmatfile'%c.name)

    elif c.apply_transform:
        datagrabber = c.datagrabber_apply.create_dataflow()
        infosource = datagrabber.get_node('subject_id_iterable')
        xform = pe.MapNode(fsl.FLIRT(interp=c.interpolation,apply_xfm=True),name='flirt',iterfield=['in_file'])
        wf.connect(datagrabber,'datagrabber.reg_mat',xform,'in_matrix_file')

    else:
        raise Exception("Need to either create or apply a flirt transform!!")

    wf.connect(datagrabber,'datagrabber.inputs',xform,'in_file')
    wf.connect(datagrabber,'datagrabber.template',xform,'reference')
    wf.connect(infosource,'subject_id',sink,'container')
    wf.connect(xform,'out_file',sink,'%s.@outfile'%c.name)

    subs = lambda sub_id: [('_subject_id_%s'%sub_id,'')]+[('_flirt%d'%i,'') for i in range(20)]
    wf.connect(infosource,('subject_id', subs),sink,'substitutions')

    return wf
示例#6
0
def mni2bold(bold, anat, standard, mask, workdir):
    """
    Use fsl.FLIRT to transform a mask from MNI to subject space
    """

    os.makedirs(workdir)

    # bold to anat
    bold2anat = fsl.FLIRT(dof=6,
                          no_clamp=True,
                          in_file=bold,
                          reference=anat,
                          out_matrix_file=join(workdir, 'bold2anat.txt'),
                          out_file=join(workdir, 'bold2anat.nii.gz'))
    bold2anat.run()

    # anat to mni
    anat2mni = fsl.FLIRT(dof=12,
                         in_file=anat,
                         reference=standard,
                         out_matrix_file=join(workdir, 'anat2mni.txt'),
                         out_file=join(workdir, sub, run,
                                       '%s_%s_anat2mni.nii.gz' % (sub, run)))
    anat2mni.run()

    # concatinate matrices
    concat = ConvertXFM(concat_xfm=True,
                        in_file2=join(workdir, sub, run,
                                      '%s_%s_bold2anat.txt' % (sub, run)),
                        in_file=join(workdir, sub, run,
                                     '%s_%s_anat2mni.txt' % (sub, run)),
                        out_file=join(workdir, sub, run,
                                      '%s_%s_bold2mni.txt' % (sub, run)))
    concat.run()

    # inverse transmatrix
    inverse = ConvertXFM(in_file=join(workdir, sub, run,
                                      '%s_%s_bold2mni.txt' % (sub, run)),
                         out_file=join(workdir, sub, run,
                                       '%s_%s_mni2bold.txt' % (sub, run)),
                         invert_xfm=True)
    inverse.run()

    # apply to mask
    mni2bold = fsl.FLIRT(
        interp='nearestneighbour',
        apply_xfm=True,
        in_matrix_file=join(workdir, sub, run,
                            '%s_%s_mni2bold.txt' % (sub, run)),
        in_file=join(mask),
        reference=join(data_basedir, sub, 'BOLD', run, 'bold.nii.gz'),
        out_file=join(workdir, sub, run, '%s_%s_roimask.nii.gz' % (sub, run)))
    mni2bold.run()

    mask_subjspace = join(workdir, sub, run,
                          '%s_%s_roimask.nii.gz' % (sub, run))

    # return path of created mask
    return mask_subjspace
示例#7
0
def mask2subjspace(sub, run, data_basedir, workdir, mask):
    """
    Use fsl.FLIRT to transform roi mask from MNI to subject space
    (without brain extraction).
    """
    from nipype.interfaces import fsl
    from nipype.interfaces.fsl.utils import ConvertXFM
    from os.path import join
    import os

    os.makedirs(join(workdir, sub, run))

    # bold to anat
    bold2anat = fsl.FLIRT(
        dof=6, no_clamp=True,
        in_file=join(data_basedir, sub, 'BOLD', run, 'bold.nii.gz'),
        reference=join(data_basedir, sub, 'anatomy', 'highres001.nii.gz'),
        out_matrix_file=join(workdir, sub, run, '%s_%s_bold2anat.txt' % (sub, run)),
        out_file=join(workdir, sub, run, '%s_%s_bold2anat.nii.gz' % (sub, run)))
    bold2anat.run()

    # anat to mni
    anat2mni = fsl.FLIRT(
        dof=12, interp='nearestneighbour',
        in_file=join(data_basedir, sub, 'anatomy', 'highres001.nii.gz'),
        reference='/usr/share/fsl/5.0//data/standard/MNI152_T1_2mm_brain.nii.gz',
        out_matrix_file=join(workdir, sub, run, '%s_%s_anat2mni.txt' % (sub, run)),
        out_file=join(workdir, sub, run, '%s_%s_anat2mni.nii.gz' % (sub, run)))
    anat2mni.run()

    # concatinate matrices
    concat = ConvertXFM(
        concat_xfm=True,
        in_file2=join(workdir, sub, run, '%s_%s_bold2anat.txt' % (sub, run)),
        in_file=join(workdir, sub, run, '%s_%s_anat2mni.txt' % (sub, run)),
        out_file=join(workdir, sub, run, '%s_%s_bold2mni.txt' % (sub, run)))
    concat.run()

    # inverse transmatrix
    inverse = ConvertXFM(
        in_file=join(workdir, sub, run, '%s_%s_bold2mni.txt' % (sub, run)),
        out_file=join(workdir, sub, run, '%s_%s_mni2bold.txt' % (sub, run)),
        invert_xfm=True)
    inverse.run()

    # apply to mask
    mni2bold = fsl.FLIRT(
        interp='nearestneighbour',
        apply_xfm=True,
        in_matrix_file=join(workdir, sub, run, '%s_%s_mni2bold.txt' % (sub, run)),
        in_file=join(mask),
        reference=join(data_basedir, sub, 'BOLD', run, 'bold.nii.gz'),
        out_file=join(workdir, sub, run, '%s_%s_roimask.nii.gz' % (sub, run)))
    mni2bold.run()

    mask_subjspace = join(workdir, sub, run, '%s_%s_roimask.nii.gz' % (sub, run))

    # return path of created mask
    return mask_subjspace
示例#8
0
文件: fmri.py 项目: bpinsard/misc
def epi_unwrap(name='epi_unwrap'):

    inputnode = pe.Node(
        utility.IdentityInterface(
            fields=['fieldmap', 'fieldmap_mask', 'fieldmap_to_epi',
                    'epi_file','epi_reference',
                    'echo_time','echo_spacing','unwarp_direction']),
        name='inputspec')
    outputnode = pe.Node(
        utility.IdentityInterface(
            fields=['unwarped_epi','voxel_shift_map']),
        name='outputspec')
    
    n_fieldmap_to_epi = pe.Node(
        fsl.FLIRT(apply_xfm=True,
                  no_resample_blur=True),
        name='fieldmap_to_epi')

    n_mask_to_epi = pe.Node(
        fsl.FLIRT(apply_xfm=True,
                  interp='nearestneighbour'),
        name='mask_to_epi')
    

    n_epi_voxelshiftmap = pe.Node(
        fsl.FUGUE(shift_out_file='vsm_epi.nii.gz',),
        name='epi_voxelshiftmap')

    n_unwarp_epi = pe.Node(
        fsl.FUGUE(),
        name='unwarp_epi')


    w=pe.Workflow(name=name)

    w.connect([
       (inputnode, n_fieldmap_to_epi, [
                    ('fieldmap_to_epi','in_matrix_file'),
                    ('fieldmap','in_file'),
                    ('epi_reference','reference'),]),
       (inputnode, n_mask_to_epi, [
                    ('fieldmap_to_epi','in_matrix_file'),
                    ('fieldmap_mask','in_file'),
                    ('epi_reference','reference'),]),
       
       (n_fieldmap_to_epi,n_epi_voxelshiftmap,[('out_file','fmap_in_file')]),
       (n_mask_to_epi, n_epi_voxelshiftmap, [('out_file','mask_file')]),
       (inputnode, n_epi_voxelshiftmap,[
                    ('epi_reference','in_file'),
                    ('unwarp_direction','unwarp_direction'),
                    ('echo_spacing','dwell_time')]),
       (n_mask_to_epi, n_unwarp_epi, [('out_file','mask_file')]),
       (n_epi_voxelshiftmap,n_unwarp_epi,[('shift_out_file','shift_in_file')]),
       (inputnode,n_unwarp_epi,[
                    ('epi_file','in_file'),]),
       ])
    
    return w
示例#9
0
    def linear_registration_( self ):
        """Linear registration. First part in the study template creation. Estimation of the registration parameters of GM to grey matter standard template."""
        try:
        #
        #
            #
            # Retrieve the GM tissue prior
            avg152T1_gray = ""
            if os.environ.get('FSLDIR'):
                avg152T1_gray = os.path.join( os.environ.get('FSLDIR'), 
                                              "data","standard","tissuepriors", "avg152T1_gray.hdr" )
            else:
                raise Exception( "$FSLDIR env variable is not setup on your system" )

            #
            # Loop on the tasks
            while True:
                # get the item
                item = self.queue_[0].get()
                # registration estimation
                flt = fsl.FLIRT()
                flt.inputs.in_file         = os.path.join( self.maps_dir_, item )
                flt.inputs.reference       = avg152T1_gray
                flt.inputs.out_file        = os.path.join( self.template_dir_, "%s_li_MNI.nii.gz"%item[:-7] )
                flt.inputs.out_matrix_file = os.path.join( self.template_dir_, "%s_li_MNI.mat"%item[:-7] )
                flt.inputs.dof             = 12
                res = flt.run()
                # apply registration 
                flt = fsl.FLIRT()
                flt.inputs.in_file         = os.path.join( self.maps_dir_, item )
                flt.inputs.reference       = avg152T1_gray
                flt.inputs.out_file        = os.path.join( self.template_dir_, "%s_li_MNI.nii.gz"%item[:-7] )
                flt.inputs.in_matrix_file  = os.path.join( self.template_dir_, "%s_li_MNI.mat"%item[:-7] )
                flt.inputs.out_matrix_file = os.path.join( self.template_dir_, "%s_li_MNI_apply.mat"%item[:-7] )
                flt.inputs.apply_xfm       = True
                flt.inputs.dof             = 12
                res = flt.run()
                # lock and add the file
                singlelock.acquire()
                self.linear_MNI_.append( flt.inputs.out_file )
                singlelock.release()
                # job is done
                self.queue_[0].task_done()
        #
        #
        except Exception as inst:
            print inst
            _log.error(inst)
            quit(-1)
        except IOError as e:
            print "I/O error({0}): {1}".format(e.errno, e.strerror)
            quit(-1)
        except:
            print "Unexpected error:", sys.exc_info()[0]
            quit(-1)
示例#10
0
    def flirt_registration(self, keepfiles=False):
        """

        """
        def _ssos(data):
            """Squared sum of squares from multichannel complex data"""
            ssos = np.sqrt(np.mean(np.absolute(data), axis=self.rcvrdim))
            return ssos

        # make workdir if does not exist
        if not os.path.exists(self.workdir):
            os.makedirs(self.workdir)

        # make 6d nifti data for flirt affine transform
        img_6d = vj.util.make_6d(self.imgspace)
        # making niftis
        img_out = self.workdir + '/composer_img_main'
        ref_out = self.workdir + '/composer_ref_main'
        flirt_out = self.workdir + '/composer_flirtout'
        full = self.workdir + '/composer_6d_img'

        writer = vj.io.NiftiWriter(_ssos(self.imgspace), self.procpar,\
                                        input_space='local',\
                                        output_space='scanner')
        writer.write(img_out)
        writer = vj.io.NiftiWriter(_ssos(self.imgspace_ref), self.procpar_ref,\
                                        input_space='local',\
                                        output_space='scanner')
        writer.write(ref_out)
        writer = vj.io.NiftiWriter(img_6d, self.procpar_ref,\
                                        input_space='local',\
                                        output_space='scanner')
        writer.write(full)

        # registering by combined magnitude FSL FLIRT
        flirt = fsl.FLIRT()
        flirt.inputs.in_file = img_out + '.nii.gz'
        flirt.inputs.reference = ref_out + '.nii.gz'
        flirt.inputs.out_file = flirt_out + '.nii.gz'
        flirt.inputs.out_matrix_file = 'composer_invol2refvolmat'
        print(flirt.cmdline)
        res = flirt.run()
        # applying the resulting transform to full data
        flirt = fsl.FLIRT()
        flirt.inputs.in_file = img_out + '.nii.gz'
        flirt.inputs.reference = ref_out + '.nii.gz'
        flirt.inputs.out_file = flirt_out + '.nii.gz'
        flirt.inputs.out_matrix_file = 'composer_invol2refvolmat'
        print(flirt.cmdline)
        vj.io.NiftiReader(flirt_out + '.nii.gz')
        # loading result nifti

        rdr = vj.io.NiftiReader(flirt_out + '.nii.gz')
示例#11
0
def coreg_vent_CSF_to_diff(dwi_dir, csf_loc, mni_csf_loc):
    import nipype.interfaces.fsl as fsl
    import nipype.pipeline.engine as pe
    print('\nTransforming CSF mask to diffusion space...')
    merged_f_samples_path = "%s%s" % (dwi_dir, '/merged_f1samples.nii.gz')
    if os.path.exists(merged_f_samples_path) is True:
        dwi_infile = merged_f_samples_path
    else:
        dwi_infile = "%s%s" % (dwi_dir, '/dwi.nii.gz')

    csf_mask_diff_out = "%s%s" % (dwi_dir, '/csf_diff.nii.gz')
    flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                    name='coregister')
    flirt.inputs.reference = dwi_infile
    flirt.inputs.in_file = csf_loc
    flirt.inputs.out_file = csf_mask_diff_out
    flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
    flirt.inputs.in_matrix_file = "%s%s" % (dwi_dir, '/xfms/MNI2diff.mat')
    flirt.inputs.apply_xfm = True
    flirt.run()

    vent_mask_diff_out = dwi_dir + '/ventricle_diff.nii.gz'
    flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                    name='coregister')
    flirt.inputs.reference = dwi_infile
    flirt.inputs.in_file = mni_csf_loc
    flirt.inputs.out_file = vent_mask_diff_out
    flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
    flirt.inputs.in_matrix_file = "%s%s" % (dwi_dir, '/xfms/MNI2diff.mat')
    flirt.inputs.apply_xfm = True
    flirt.run()

    # Mask CSF with MNI ventricle mask
    print('Masking CSF with ventricle mask...')
    vent_csf_diff_out = "%s%s" % (dwi_dir, '/vent_csf_diff.nii.gz')
    args = "%s%s" % ('-mas ', vent_mask_diff_out)
    maths = fsl.ImageMaths(in_file=csf_mask_diff_out,
                           op_string=args,
                           out_file=vent_csf_diff_out)
    os.system(maths.cmdline)

    print('Eroding and binarizing CSF mask...')
    # Erode CSF mask
    out_file_final = "%s%s" % (vent_csf_diff_out.split('.nii.gz')[0],
                               '_ero.nii.gz')
    args = '-ero -bin'
    maths = fsl.ImageMaths(in_file=vent_csf_diff_out,
                           op_string=args,
                           out_file=out_file_final)
    os.system(maths.cmdline)
    return out_file_final
示例#12
0
def mask2pe(
        pe,
        anat,
        mnimask,
        workdir,
        standard='/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm_brain.nii.gz'
):
    """
    Compute new 2-step projection for a masn from mni to 3D parameter space (and apply it).
    """

    # create transformation matrix from mni to anatomical
    mni2anat = fsl.FLIRT(dof=12,
                         interp='trilinear',
                         in_file=standard,
                         reference=anat,
                         out_file=join(workdir, 'mni2anat.nii.gz'),
                         out_matrix_file=join(workdir, 'mni2anat.txt'))
    mni2anat.run()

    # anat to parameter estimate map (3D statistical volume)
    anat2pe = fsl.FLIRT(dof=6,
                        interp='trilinear',
                        in_file=anat,
                        reference=pe,
                        out_file=join(workdir, 'anat2pe.nii.gz'),
                        out_matrix_file=join(workdir, 'anat2pe.txt'))
    anat2pe.run()

    # concatinate matrices
    concat = ConvertXFM(concat_xfm=True,
                        in_file2=join(workdir, 'mni2anat.txt'),
                        in_file=join(workdir, 'anat2pe.txt'),
                        out_file=join(workdir, 'mni2pe.txt'))
    concat.run()

    # set path to output file
    outfile = join(workdir, 'mask2pe.nii.gz')

    # apply transformation to mask image
    mni2pe = fsl.FLIRT(interp='nearestneighbour',
                       apply_xfm=True,
                       in_matrix_file=join(workdir, 'mni2pe.txt'),
                       out_matrix_file=join(workdir, 'mask2pe.txt'),
                       in_file=mnimask,
                       reference=pe,
                       out_file=outfile)
    mni2pe.run()

    # return path to transformed result
    return outfile
示例#13
0
 def init_fsl(self, in_file: str, ref: str, out_file: str, out_mat: str):
     ax = fsl.FLIRT()
     ax.inputs.in_file = in_file
     ax.inputs.reference = ref
     ax.inputs.out_file = out_file
     ax.inputs.out_matrix_file = out_mat
     return ax
示例#14
0
def create_workflow():
    workflow = Workflow(
        name='transform_manual_mask')

    inputs = Node(IdentityInterface(fields=[
        'subject_id',
        'session_id',
        'refsubject_id',
        'ref_funcmask',
        'ref_func',
        'funcs',
    ]), name='in')

    # Find the transformation matrix func_ref -> func
    # First find transform from func to manualmask's ref func

    # first take the median (flirt functionality has changed and no longer automatically takes the first volume when given 4D files)
    median_func = MapNode(
                    interface=fsl.maths.MedianImage(dimension="T"),
                    name='median_func',
                    iterfield=('in_file'),
                    )
    findtrans = MapNode(fsl.FLIRT(),
                        iterfield=['in_file'],
                        name='findtrans'
                        )

    # Invert the matrix transform
    invert = MapNode(fsl.ConvertXFM(invert_xfm=True),
                     name='invert',
                     iterfield=['in_file'],
                     )
    workflow.connect(findtrans, 'out_matrix_file',
                     invert, 'in_file')

    # Transform the manualmask to be aligned with func
    funcreg = MapNode(ApplyXFMRefName(),
                      name='funcreg',
                      iterfield=['in_matrix_file', 'reference'],
                      )


    workflow.connect(inputs, 'funcs',
                     median_func, 'in_file')

    workflow.connect(median_func, 'out_file',
                     findtrans, 'in_file')
    workflow.connect(inputs, 'ref_func',
                     findtrans, 'reference')

    workflow.connect(invert, 'out_file',
                     funcreg, 'in_matrix_file')

    workflow.connect(inputs, 'ref_func',
                     funcreg, 'in_file')
    workflow.connect(inputs, 'funcs',
                     funcreg, 'reference')

    
    return workflow
示例#15
0
def reg_parcels2diff(dwi_dir, seeds_dir):
    import re
    import nipype.interfaces.fsl as fsl
    import nipype.pipeline.engine as pe
    merged_f_samples_path = "%s%s" % (dwi_dir, '/merged_f1samples.nii.gz')
    if os.path.exists(merged_f_samples_path) is True:
        dwi_infile = merged_f_samples_path
    else:
        dwi_infile = "%s%s" % (dwi_dir, '/dwi.nii.gz')

    seeds_list = [i for i in os.listdir(seeds_dir) if '.nii' in i]

    def atoi(text):
        return int(text) if text.isdigit() else text

    def natural_keys(text):
        return [atoi(c) for c in re.split('(\d+)', text)]

    seeds_list.sort(key=natural_keys)
    i = 0
    for parcel in seeds_list:
        out_file = "%s%s%s%s" % (seeds_dir, '/region_', str(i), '_diff.nii.gz')
        flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                        name='coregister')
        flirt.inputs.reference = dwi_infile
        flirt.inputs.in_file = "%s%s%s" % (seeds_dir, '/', parcel)
        flirt.inputs.out_file = out_file
        flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
        flirt.inputs.apply_xfm = True
        flirt.inputs.in_matrix_file = "%s%s" % (dwi_dir, '/xfms/MNI2diff.mat')
        flirt.run()
        i = i + 1
    seeds_list = [i for i in os.listdir(seeds_dir) if 'diff.nii' in i]
    return seeds_list
示例#16
0
文件: nodes.py 项目: IBT-FMI/SAMRI
def autorotate(
    template,
    in_file='structural.nii',
):
    """Multi-rotation-state transformation start. This allows the registration to commence with the best rotational fit, and may help if the orientation of the data is malformed with respect to the header.
	
	Parameters
	----------
	
	template : string
		Full path to template data.
	in_file : string
		Name of input NIfTI file with data which is to be transformed.

	Returns
	-------
	
	flt_res : Path names of output_file, out_log, and out_matrix_file (affine transformation).
	"""
    flt = fsl.FLIRT(bins=640, cost_func='mutualinfo')
    flt.inputs.in_file = in_file
    flt.inputs.reference = template
    flt.inputs.output_type = "NIFTI_GZ"
    flt.inputs.dof = 6
    flt.input.searchr_x = [-180, 180]
    flt.input.searchr_y = [-180, 180]
    flt.input.searchr_z = [-180, 180]
    flt.input.force_scaling = True
    flt.cmdline
    flt_res = flt.run()
    return flt_res
示例#17
0
def epi_sbref_registration(name='EPI_SBrefRegistration'):
    workflow = pe.Workflow(name=name)
    inputnode = pe.Node(
        niu.IdentityInterface(fields=['epi_brain', 'sbref_brain']),
        name='inputnode')
    outputnode = pe.Node(
        niu.IdentityInterface(fields=['epi_registered', 'out_mat']),
        name='outputnode')

    mean = pe.Node(fsl.MeanImage(dimension='T'), name='EPImean')
    inu = pe.Node(ants.N4BiasFieldCorrection(dimension=3), name='EPImeanBias')
    epi_sbref = pe.Node(fsl.FLIRT(dof=6, out_matrix_file='init.mat'),
                        name='EPI2SBRefRegistration')

    epi_split = pe.Node(fsl.Split(dimension='t'), name='EPIsplit')
    epi_xfm = pe.MapNode(fsl.ApplyXfm(),
                         name='EPIapplyxfm',
                         iterfield=['in_file'])
    epi_merge = pe.Node(fsl.Merge(dimension='t'), name='EPImergeback')
    workflow.connect([
        (inputnode, epi_split, [('epi_brain', 'in_file')]),
        (inputnode, epi_sbref, [('sbref_brain', 'reference')]),
        (inputnode, epi_xfm, [('sbref_brain', 'reference')]),
        (inputnode, mean, [('epi_brain', 'in_file')]),
        (mean, inu, [('out_file', 'input_image')]),
        (inu, epi_sbref, [('output_image', 'in_file')]),
        (epi_split, epi_xfm, [('out_files', 'in_file')]),
        (epi_sbref, epi_xfm, [('out_matrix_file', 'in_matrix_file')]),
        (epi_xfm, epi_merge, [('out_file', 'in_files')]),
        (epi_sbref, outputnode, [('out_matrix_file', 'out_mat')]),
        (epi_merge, outputnode, [('merged_file', 'epi_registered')])
    ])
    return workflow
示例#18
0
def apply_xfm_node(config: dict, **kwargs):
    '''
    Parses config file to return desired apply_xfm node.
    Parameters
    ----------
    config : dict
        PALS config file
    kwargs
        Keyword arguments to send to registration method.

    Returns
    -------
    MapNode
    '''

    if (not config['Analysis']['Registration']):
        # No registration; no xfm to apply.
        n = MapNode(Function(function=infile_to_outfile,
                             input_names=['in_file', 'in_matrix_file'],
                             output_names='out_file'),
                    name='transformation_skip',
                    iterfield=['in_file', 'in_matrix_file'])
    else:
        n = MapNode(fsl.FLIRT(apply_xfm=True,
                              reference=config['Registration']['reference']),
                    name='transformation_flirt',
                    iterfield=['in_file', 'in_matrix_file'])
    return n
示例#19
0
def registration_node(config: dict, **kwargs):
    '''
    Parses config file to return desired registration method.
    Parameters
    ----------
    config : dict
        PALS config file
    kwargs
        Keyword arguments to send to registration method.

    Returns
    -------
    MapNode
    '''
    # Get registration method
    reg_method = config['Analysis']['RegistrationMethod']
    if (not config['Analysis']['Registration']):
        # No registration; in -> out
        n = MapNode(Function(function=reg_no_reg,
                             input_names=['in_file'],
                             output_names=['out_file', 'out_matrix_file']),
                    name='registration_identity',
                    iterfield='in_file')
    elif (reg_method.lower() == 'flirt'):
        # Use FLIRT
        n = MapNode(fsl.FLIRT(),
                    name='registration_flirt',
                    iterfield='in_file')
        for k, v in kwargs.items():
            setattr(n.inputs, k, v)
    else:
        raise (NotImplementedError(
            f'Registration method {reg_method} not implemented.'))
    return n
示例#20
0
def registration(in_file, out_file, reference):
    fsl.FSLCommand.set_default_output_type('NIFTI')
    flt = fsl.FLIRT(bins=640, cost_func='mutualinfo')
    flt.inputs.in_file = in_file
    flt.inputs.out_file = out_file
    flt.inputs.reference = reference
    result = flt.run()
示例#21
0
文件: fmri.py 项目: bpinsard/misc
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
示例#22
0
def func2mni_wf():

    mni_skull_2mm = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm.nii.gz'
    mni_brain_2mm   = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm_brain.nii.gz'

    flow  = Workflow('func2mni_nonlinear')

    inputnode  = Node(util.IdentityInterface(fields=['func_image',
                                                     'reference_image',
                                                     'func2anat_affine',
                                                     'anat2mni_warp']),name = 'inputnode')

    outputnode = Node(util.IdentityInterface(fields=['func2mni_2mm',
                                                     'func2mni_4mm']),name = 'outputnode')

    applywarp = Node(fsl.ApplyWarp(), name = 'apply_warp',)
    applywarp.inputs.ref_file            = mni_brain_2mm

    flirt4mm = Node(fsl.FLIRT(), name = 'resample_4mm')
    flirt4mm.inputs.reference         = mni_brain_2mm
    flirt4mm.inputs.apply_isoxfm      = 4.0

    flow.connect(inputnode, 'func_image'        , applywarp,  'in_file')
    flow.connect(inputnode, 'anat2mni_warp'     , applywarp,  'field_file')
    flow.connect(inputnode, 'func2anat_affine'  , applywarp,  'premat')
    flow.connect(applywarp, 'out_file'          , flirt4mm,   'in_file')

    flow.connect(applywarp, 'out_file'          , outputnode, 'func2mni_2mm')
    flow.connect(flirt4mm,  'out_file'          , outputnode, 'func2mni_4mm')

    return flow
示例#23
0
def register_dwi_files_to_super_b0(dwi_files, super_b0 , out_dir, force_run = True):
    """
        Register list of dwi files to super b0 (both paths)
    """

    processed_files = []
    registered_dir = os.path.join(out_dir, 'registered_dwi_files')
    logger.info("Creaging dwi directory {}".format(registered_dir))
    make_dir_safe(registered_dir)

    flirt = fsl.FLIRT()
    flirt.inputs.reference = super_b0
    flirt.inputs.interp = 'sinc'
    flirt.inputs.sinc_width = 7
    flirt.inputs.sinc_window = 'blackman'
    flirt.inputs.no_search = False
    flirt.inputs.verbose = 1
    flirt.inputs.padding_size = 1
    flirt.inputs.output_type = 'NIFTI'

    for i, dwi_file in enumerate(dwi_files):

        flirt.inputs.in_file = dwi_file
        flirt.inputs.out_file = os.path.join(registered_dir, "flirt-{num:02d}.nii".format(num = i+1))
        processed_files.append(flirt.inputs.out_file)
        flirt.inputs.out_matrix_file = os.path.join(registered_dir, "flirt-{num:02d}.txt".format(num = i+1))
        if not os.path.isfile(flirt.inputs.out_matrix_file) or force_run:
            flirt.run()

    return processed_files
示例#24
0
def coreg_mask_to_diff(dwi_dir, mask):
    import nipype.interfaces.fsl as fsl
    import nipype.pipeline.engine as pe
    print('\nTransforming custom waypoint mask to diffusion space...')
    merged_f_samples_path = "%s%s" % (dwi_dir, '/merged_f1samples.nii.gz')
    if os.path.exists(merged_f_samples_path) is True:
        dwi_infile = merged_f_samples_path
    else:
        dwi_infile = "%s%s" % (dwi_dir, '/dwi.nii.gz')

    out_file = "%s%s" % (dwi_dir, '/mask_custom_diff.nii.gz')
    flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                    name='coregister')
    flirt.inputs.reference = dwi_infile
    flirt.inputs.in_file = mask
    flirt.inputs.out_file = out_file
    flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
    flirt.inputs.in_matrix_file = "%s%s" % (dwi_dir, '/xfms/MNI2diff.mat')
    flirt.inputs.apply_xfm = True
    flirt.run()
    args = '-bin'
    maths = fsl.ImageMaths(in_file=out_file, op_string=args, out_file=out_file)
    print('\nBinarizing custom mask...')
    os.system(maths.cmdline)
    return out_file
示例#25
0
def linear_registration(
    in_file: Path,
    ref: Path,
    out_file: Path,
    out_mat: Path = None,
    coregister: bool = False,
):
    """
    Wrap inputs into FSL's FLIRT interface for linear registraions.

    Parameters
    ----------
    in_file : Path
        Path to "moving" file
    ref : Path
        Path to reference file
    out_file : Path
        Path to output registered file
    coregister : bool, optional
        Indicating whether it's a within-subject registration, by default False
    """
    if not out_mat:
        in_name = in_file.name.split(".")[0]
        ref_name = ref.name.split(".")[0]
        out_mat = out_file.parent / f"{in_name}-{ref_name}_affine.mat"
    flt = fsl.FLIRT()
    flt.inputs.in_file = in_file
    flt.inputs.reference = ref
    flt.inputs.out_file = out_file
    if coregister:
        flt.inputs.cost = "mutualinfo"
    flt.inputs.out_matrix_file = out_mat
    return flt
示例#26
0
 def FLIRT(self, in_file: str, ref: str, out_dir: str, type: int):
     """
     FLIRT linear transformation
     @param in_file: image to be transformed
     @param ref: image to transform into
     @param out_dir: directory for outputs
     @param type: 0 for highres2lowres, 1 for atlasHighres2highres, 2 for atlasLabels2highres
     @return:
     """
     flt = fsl.FLIRT()
     flt.inputs.in_file = in_file
     flt.inputs.reference = ref
     flt.inputs.bins = 256
     flt.inputs.cost = "corratio"
     flt.inputs.searchr_x = [-90, 90]
     flt.inputs.searchr_y = [-90, 90]
     flt.inputs.searchr_z = [-90, 90]
     flt.inputs.dof = 12
     flt.inputs.interp = "trilinear"
     if type == 0:
         flt.inputs.out_file = f"{out_dir}/Highres2Lowres_linear.nii"
         flt.inputs.out_matrix_file = f"{out_dir}/Highres2Lowres_linear.mat"
         print("Running linear transformation from Highres to Lowres:")
     elif type == 1:
         flt.inputs.out_file = f"{out_dir}/HighresAtlas2Highres_linear.nii"
         flt.inputs.out_matrix_file = f"{out_dir}/HighresAtlas2Highres_linear.mat"
         print("Running linear transformation from Atlas to Highres:")
     elif type == 2:
         flt.inputs.out_file = f"{out_dir}/LabelsAtlas2Highres_linear.nii"
         flt.inputs.out_matrix_file = f"{out_dir}/LabelsAtlas2Highres_linear.mat"
         print("Running linear transformation from Atlas to Highres:")
     flt.inputs.output_type = "NIFTI"
     print(flt.cmdline)
     flt.run()
     return flt.inputs.out_matrix_file
示例#27
0
def reg_parcels2diff(bedpostx_dir):
    import re
    import nipype.interfaces.fsl as fsl
    import nipype.pipeline.engine as pe
    merged_f_samples_path = bedpostx_dir + '/merged_f1samples.nii.gz'
    volumes_dir = bedpostx_dir + '/volumes'
    volumes_list = [i for i in os.listdir(volumes_dir) if '.nii' in i]

    def atoi(text):
        return int(text) if text.isdigit() else text

    def natural_keys(text):
        return [atoi(c) for c in re.split('(\d+)', text)]

    volumes_list.sort(key=natural_keys)
    i = 0
    for parcel in volumes_list:
        out_file = volumes_dir + '/region_' + str(i) + '_diff.nii.gz'
        flirt = pe.Node(interface=fsl.FLIRT(cost_func='mutualinfo'),
                        name='coregister')
        flirt.inputs.reference = merged_f_samples_path
        flirt.inputs.in_file = volumes_dir + '/' + parcel
        flirt.inputs.out_file = out_file
        flirt.inputs.out_matrix_file = '/tmp/out_flirt.mat'
        flirt.inputs.apply_xfm = True
        flirt.inputs.in_matrix_file = bedpostx_dir + '/xfms/MNI2diff.mat'
        flirt.run()
        i = i + 1
    volumes_list = [i for i in os.listdir(volumes_dir) if 'diff.nii' in i]
    return volumes_list
示例#28
0
def create_eddy_correct_pipeline(name='eddy_correct'):
    """

    .. deprecated:: 0.9.3
      Use :func:`nipype.workflows.dmri.preprocess.epi.ecc_pipeline` instead.


    Creates a pipeline that replaces eddy_correct script in FSL. It takes a
    series of diffusion weighted images and linearly co-registers them to one
    reference image. No rotation of the B-matrix is performed, so this pipeline
    should be executed after the motion correction pipeline.

    Example
    -------

    >>> nipype_eddycorrect = create_eddy_correct_pipeline('nipype_eddycorrect')
    >>> nipype_eddycorrect.inputs.inputnode.in_file = 'diffusion.nii'
    >>> nipype_eddycorrect.inputs.inputnode.ref_num = 0
    >>> nipype_eddycorrect.run() # doctest: +SKIP

    Inputs::

        inputnode.in_file
        inputnode.ref_num

    Outputs::

        outputnode.eddy_corrected
    """

    warnings.warn(
        ('This workflow is deprecated from v.1.0.0, use '
         'nipype.workflows.dmri.preprocess.epi.ecc_pipeline instead'),
        DeprecationWarning)

    inputnode = pe.Node(niu.IdentityInterface(fields=['in_file', 'ref_num']),
                        name='inputnode')

    pipeline = pe.Workflow(name=name)

    split = pe.Node(fsl.Split(dimension='t'), name='split')
    pick_ref = pe.Node(niu.Select(), name='pick_ref')
    coregistration = pe.MapNode(fsl.FLIRT(no_search=True,
                                          padding_size=1,
                                          interp='trilinear'),
                                name='coregistration',
                                iterfield=['in_file'])
    merge = pe.Node(fsl.Merge(dimension='t'), name='merge')
    outputnode = pe.Node(niu.IdentityInterface(fields=['eddy_corrected']),
                         name='outputnode')

    pipeline.connect([(inputnode, split, [('in_file', 'in_file')]),
                      (split, pick_ref, [('out_files', 'inlist')]),
                      (inputnode, pick_ref, [('ref_num', 'index')]),
                      (split, coregistration, [('out_files', 'in_file')]),
                      (pick_ref, coregistration, [('out', 'reference')]),
                      (coregistration, merge, [('out_file', 'in_files')]),
                      (merge, outputnode, [('merged_file', 'eddy_corrected')])
                      ])
    return pipeline
示例#29
0
def get_norm_wf(name="norm_wf"):
    wf = Workflow(name=name)

    inputnode = pe.Node(niu.IdentityInterface(fields=['t1w', 't1w_brain']),
                        name='inputnode')
    outputnode = pe.Node(niu.IdentityInterface(
        fields=['t1w_2_MNI_mat', 't1w_2_MNI_warp', 't1w_MNIspace']),
                         name='outputnode')
    # otherwise fnirt is trying to write to the sourcedata dir
    t1w_dummy = pe.Node(fsl.ImageMaths(), name="t1w_dummy")
    wf.connect(inputnode, "t1w", t1w_dummy, "in_file")

    t1w_2_MNI_flirt = pe.Node(fsl.FLIRT(dof=12), name='t1w_2_MNI_flirt')
    t1w_2_MNI_flirt.inputs.reference = fsl.Info.standard_image(
        'MNI152_T1_1mm_brain.nii.gz')
    wf.connect(inputnode, 't1w_brain', t1w_2_MNI_flirt, 'in_file')
    wf.connect(t1w_2_MNI_flirt, 'out_matrix_file', outputnode, 't1w_2_MNI_mat')

    # 2. CALC. WARP STRUCT -> MNI with FNIRT
    # cf. wrt. 2mm
    # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1311&L=FSL&P=R86108&1=FSL&9=A&J=on&d=No+Match%3BMatch%3BMatches&z=4
    t1w_2_MNI_fnirt = pe.Node(fsl.FNIRT(), name='t1w_2_MNI_fnirt')
    t1w_2_MNI_fnirt.inputs.config_file = 'T1_2_MNI152_2mm'
    t1w_2_MNI_fnirt.inputs.ref_file = fsl.Info.standard_image(
        'MNI152_T1_2mm.nii.gz')
    t1w_2_MNI_fnirt.inputs.field_file = True
    t1w_2_MNI_fnirt.plugin_args = {'submit_specs': 'request_memory = 4000'}
    wf.connect(t1w_dummy, 'out_file', t1w_2_MNI_fnirt, 'in_file')
    wf.connect(t1w_2_MNI_flirt, 'out_matrix_file', t1w_2_MNI_fnirt,
               'affine_file')

    wf.connect(t1w_2_MNI_fnirt, 'field_file', outputnode, 't1w_2_MNI_warp')
    wf.connect(t1w_2_MNI_fnirt, 'warped_file', outputnode, 't1w_MNIspace')
    return wf
示例#30
0
def test_nonlinear_register():
    from ..registration import create_nonlinear_register

    from CPAC.pipeline import nipype_pipeline_engine as pe
    import nipype.interfaces.fsl as fsl

    ## necessary inputs
    ## -input_brain
    ## -input_skull
    ## -reference_brain
    ## -reference_skull
    ## -fnirt_config
    ## -fnirt_warp_res

    ## input_brain
    anat_bet_file = '/home/data/Projects/nuisance_reliability_paper/working_dir_CPAC_order/resting_preproc/anatpreproc/_session_id_NYU_TRT_session1_subject_id_sub05676/anat_skullstrip/mprage_anonymized_RPI_3dT.nii.gz'

    ## input_skull

    ## reference_brain
    mni_file = '/usr/share/fsl/4.1/data/standard/MNI152_T1_3mm_brain.nii.gz'

    ## reference_skull

    ## fnirt_config
    fnirt_config = 'T1_2_MNI152_3mm'

    ## fnirt_warp_res
    fnirt_warp_res = None

    #?? what is this for?:
    func_file = '/home/data/Projects/nuisance_reliability_paper/working_dir_CPAC_order/resting_preproc/nuisance_preproc/_session_id_NYU_TRT_session1_subject_id_sub05676/_csf_threshold_0.4/_gm_threshold_0.2/_wm_threshold_0.66/_run_scrubbing_False/_nc_5/_selector_6.7/regress_nuisance/mapflow/_regress_nuisance0/residual.nii.gz'

    mni_workflow = pe.Workflow(name='mni_workflow')

    linear_reg = pe.Node(interface=fsl.FLIRT(), name='linear_reg_0')
    linear_reg.inputs.cost = 'corratio'
    linear_reg.inputs.dof = 6
    linear_reg.inputs.interp = 'nearestneighbour'

    linear_reg.inputs.in_file = func_file
    linear_reg.inputs.reference = anat_bet_file

    #T1 to MNI Node
    c = create_nonlinear_register()
    c.inputs.inputspec.input = anat_bet_file
    c.inputs.inputspec.reference = '/usr/share/fsl/4.1/data/standard/MNI152_T1_3mm_brain.nii.gz'
    c.inputs.inputspec.fnirt_config = 'T1_2_MNI152_3mm'

    #EPI to MNI warp Node
    mni_warp = pe.Node(interface=fsl.ApplyWarp(), name='mni_warp')
    mni_warp.inputs.ref_file = '/usr/share/fsl/4.1/data/standard/MNI152_T1_3mm_brain.nii.gz'
    mni_warp.inputs.in_file = func_file

    mni_workflow.connect(c, 'outputspec.nonlinear_xfm', mni_warp, 'field_file')
    mni_workflow.connect(linear_reg, 'out_matrix_file', mni_warp, 'premat')

    mni_workflow.base_dir = './'
    mni_workflow.run()