示例#1
0
def create_ants_nonlinear_xfm(name='ants_nonlinear_xfm'):

    import nipype.interfaces.ants as ants
    from nipype.interfaces.ants.legacy import GenWarpFields

    ants_nonlinear_xfm = pe.Workflow(name=name)

    inputspec = pe.Node(
        util.IdentityInterface(fields=['anatomical_brain', 'reference_brain']),
        name='inputspec')

    # use ANTS to warp the masked anatomical image to a template image
    warp_brain = pe.Node(GenWarpFields(), name='warp_brain')

    outputspec = pe.Node(util.IdentityInterface(fields=[
        'warp_field', 'affine_transformation', 'inverse_warp', 'output_brain'
    ]),
                         name='outputspec')

    ants_nonlinear_xfm.connect(inputspec, 'anatomical_brain', warp_brain,
                               'input_image')
    ants_nonlinear_xfm.connect(inputspec, 'reference_brain', warp_brain,
                               'reference_image')

    ants_nonlinear_xfm.connect(warp_brain, 'warp_field', outputspec,
                               'warp_field')
    ants_nonlinear_xfm.connect(warp_brain, 'affine_transformation', outputspec,
                               'affine_transformation')
    ants_nonlinear_xfm.connect(warp_brain, 'inverse_warp_field', outputspec,
                               'inverse_warp')
    ants_nonlinear_xfm.connect(warp_brain, 'output_file', outputspec,
                               'output_brain')

    return ants_nonlinear_xfm
示例#2
0
def test_GenWarpFields_inputs():
    input_map = dict(
        args=dict(argstr='%s', ),
        bias_field_correction=dict(argstr='-n 1', ),
        dimension=dict(
            argstr='-d %d',
            position=1,
            usedefault=True,
        ),
        environ=dict(
            nohash=True,
            usedefault=True,
        ),
        force_proceed=dict(argstr='-f 1', ),
        ignore_exception=dict(
            nohash=True,
            usedefault=True,
        ),
        input_image=dict(
            argstr='-i %s',
            copyfile=False,
            mandatory=True,
        ),
        inverse_warp_template_labels=dict(argstr='-l', ),
        max_iterations=dict(
            argstr='-m %s',
            sep='x',
        ),
        num_threads=dict(
            nohash=True,
            usedefault=True,
        ),
        out_prefix=dict(
            argstr='-o %s',
            usedefault=True,
        ),
        quality_check=dict(argstr='-q 1', ),
        reference_image=dict(
            argstr='-r %s',
            copyfile=True,
            mandatory=True,
        ),
        similarity_metric=dict(argstr='-s %s', ),
        terminal_output=dict(
            mandatory=True,
            nohash=True,
        ),
        transformation_model=dict(
            argstr='-t %s',
            usedefault=True,
        ),
    )
    inputs = GenWarpFields.input_spec()

    for key, metadata in input_map.items():
        for metakey, value in metadata.items():
            yield assert_equal, getattr(inputs.traits()[key], metakey), value
def test_GenWarpFields_outputs():
    output_map = dict(affine_transformation=dict(),
    input_file=dict(),
    inverse_warp_field=dict(),
    output_file=dict(),
    warp_field=dict(),
    )
    outputs = GenWarpFields.output_spec()

    for key, metadata in output_map.items():
        for metakey, value in metadata.items():
            yield assert_equal, getattr(outputs.traits()[key], metakey), value
def test_GenWarpFields_inputs():
    input_map = dict(ignore_exception=dict(nohash=True,
    usedefault=True,
    ),
    transformation_model=dict(usedefault=True,
    argstr='-t %s',
    ),
    quality_check=dict(argstr='-q 1',
    ),
    num_threads=dict(nohash=True,
    usedefault=True,
    ),
    force_proceed=dict(argstr='-f 1',
    ),
    args=dict(argstr='%s',
    ),
    out_prefix=dict(argstr='-o %s',
    usedefault=True,
    ),
    bias_field_correction=dict(argstr='-n 1',
    ),
    terminal_output=dict(mandatory=True,
    nohash=True,
    ),
    environ=dict(nohash=True,
    usedefault=True,
    ),
    similarity_metric=dict(argstr='-s %s',
    ),
    reference_image=dict(copyfile=True,
    mandatory=True,
    argstr='-r %s',
    ),
    input_image=dict(copyfile=False,
    mandatory=True,
    argstr='-i %s',
    ),
    inverse_warp_template_labels=dict(argstr='-l',
    ),
    dimension=dict(position=1,
    usedefault=True,
    argstr='-d %d',
    ),
    max_iterations=dict(sep='x',
    argstr='-m %s',
    ),
    )
    inputs = GenWarpFields.input_spec()

    for key, metadata in input_map.items():
        for metakey, value in metadata.items():
            yield assert_equal, getattr(inputs.traits()[key], metakey), value
def test_GenWarpFields_outputs():
    output_map = dict(
        affine_transformation=dict(),
        input_file=dict(),
        inverse_warp_field=dict(),
        output_file=dict(),
        warp_field=dict(),
    )
    outputs = GenWarpFields.output_spec()

    for key, metadata in output_map.items():
        for metakey, value in metadata.items():
            yield assert_equal, getattr(outputs.traits()[key], metakey), value
示例#6
0
def create_ants_nonlinear_xfm(name='ants_nonlinear_xfm'):
    """
    Calculates the nonlinear ANTS registration transform.

    Parameters
    ----------
    name : string, optional
        Name of the workflow.

    Returns
    -------
    ants_nonlinear_xfm : nipype.pipeline.engine.Workflow

    Notes
    -----
    
    Workflow Inputs::
    
        inputspec.anatomical_brain : string (nifti file)
            File of brain to be normalized (registered)
        inputspec.reference_brain : string (nifti file)
            Target brain file to normalize to

            
    Workflow Outputs::
    
        outputspec.warp_field : string (nifti file)
            Output warp field of registration
        outputspec.affine_transformation : text file
            Affine matrix of nonlinear transformation of brain file
        outputspec.inverse_warp : string (nifti file)
            Inverse of the warp field of the registration
        outputspec.output_brain : string (nifti file)
            Template-registered version of input brain
            
    Registration Procedure:
    
    1. Performs a nonlinear anatomical-to-template registration.
       
    Workflow Graph:
    
    .. image:: 
        :width: 500
    
    Detailed Workflow Graph:
    
    .. image:: 
        :width: 500      
    """

    from nipype.interfaces.ants.legacy import GenWarpFields

    ants_nonlinear_xfm = pe.Workflow(name=name)

    inputspec = pe.Node(
        util.IdentityInterface(fields=['anatomical_brain', 'reference_brain']),
        name='inputspec')

    # use ANTS to warp the masked anatomical image to a template image
    warp_brain = pe.Node(GenWarpFields(), name='warp_brain')

    outputspec = pe.Node(util.IdentityInterface(fields=[
        'warp_field', 'affine_transformation', 'inverse_warp', 'output_brain'
    ]),
                         name='outputspec')

    ants_nonlinear_xfm.connect(inputspec, 'anatomical_brain', warp_brain,
                               'input_image')
    ants_nonlinear_xfm.connect(inputspec, 'reference_brain', warp_brain,
                               'reference_image')

    ants_nonlinear_xfm.connect(warp_brain, 'warp_field', outputspec,
                               'warp_field')
    ants_nonlinear_xfm.connect(warp_brain, 'affine_transformation', outputspec,
                               'affine_transformation')
    ants_nonlinear_xfm.connect(warp_brain, 'inverse_warp_field', outputspec,
                               'inverse_warp')
    ants_nonlinear_xfm.connect(warp_brain, 'output_file', outputspec,
                               'output_brain')

    return ants_nonlinear_xfm
def get_struct_norm_workflow(name='normalize_struct'):
    """ Base structural workflow for normalization

    Parameters
    ----------
    name : name of workflow. Default = 'normalize_struct'

    Inputs
    ------
    inputspec.template_file :
    inputspec.brain :
    inputspec.segmentation :

    Outputs
    -------
    outputspec.warp_field :
    outputspec.affine_transformation :
    outputspec.inverse_warp :
    outputspec.unwarped_brain :
    outputspec.warped_brain :

    Returns
    -------
    workflow : structural normalization workflow
    """
    #inputs to workflow
    import nipype.interfaces.freesurfer as fs
    import nipype.interfaces.ants as ants
    from nipype.interfaces.ants.legacy import GenWarpFields
    import nipype.pipeline.engine as pe
    import nipype.interfaces.utility as util
    inputspec = pe.Node(util.IdentityInterface(
        fields=['template_file', 'brain', 'segmentation']),
                        name='inputspec')

    #converts brain from freesurfer mgz into nii
    brain_2nii = pe.Node(fs.preprocess.MRIConvert(), name='brain_2nii')
    brain_2nii.inputs.out_type = 'nii'

    #converts freesurfer segmentation into nii
    aparcaseg_2nii = pe.Node(fs.preprocess.MRIConvert(), name='aparcaseg_2nii')
    aparcaseg_2nii.inputs.out_type = 'nii'

    #create mask excluding everything outside of cortical surface (from
    #freesurfer segmentation file)
    create_mask = pe.Node(fs.model.Binarize(), name='create_mask')
    create_mask.inputs.min = 1
    create_mask.inputs.dilate = 1
    create_mask.inputs.out_type = 'nii'

    #apply mask to anatomical
    apply_mask = pe.Node(fs.utils.ApplyMask(), name='apply_mask')

    #use ANTS to warp the masked anatomical image to a template image
    warp_brain = pe.Node(GenWarpFields(), name='warp_brain')

    #collects workflow outputs
    outputspec = pe.Node(util.IdentityInterface(fields=[
        'warp_field', 'affine_transformation', 'inverse_warp',
        'unwarped_brain', 'warped_brain'
    ]),
                         name='outputspec')

    normalize_struct = pe.Workflow(name=name)
    normalize_struct.connect([
        (inputspec, warp_brain, [('template_file', 'reference_image')]),
        (inputspec, brain_2nii, [('brain', 'in_file')]),
        (inputspec, aparcaseg_2nii, [('segmentation', 'in_file')]),
        (aparcaseg_2nii, create_mask, [('out_file', 'in_file')]),
        (create_mask, apply_mask, [('binary_file', 'mask_file')]),
        (brain_2nii, apply_mask, [('out_file', 'in_file')]),
        (apply_mask, warp_brain, [('out_file', 'input_image')]),
        (apply_mask, outputspec, [('out_file', 'unwarped_brain')]),
        (warp_brain, outputspec, [('affine_transformation',
                                   'affine_transformation'),
                                  ('warp_field', 'warp_field'),
                                  ('inverse_warp_field', 'inverse_warp'),
                                  ('output_file', 'warped_brain')])
    ])

    return normalize_struct