interfaces.freesurfer.preprocess¶
ApplyVolTransform¶
Wraps the executable command mri_vol2vol.
Use FreeSurfer mri_vol2vol to apply a transform.
Examples¶
>>> from nipype.interfaces.freesurfer import ApplyVolTransform
>>> applyreg = ApplyVolTransform()
>>> applyreg.inputs.source_file = 'structural.nii'
>>> applyreg.inputs.reg_file = 'register.dat'
>>> applyreg.inputs.transformed_file = 'struct_warped.nii'
>>> applyreg.inputs.fs_target = True
>>> applyreg.cmdline
'mri_vol2vol --fstarg --reg register.dat --mov structural.nii --o struct_warped.nii'
Inputs:
[Mandatory]
source_file: (a pathlike object or string representing an existing
file)
Input volume you wish to transform
argument: ``--mov %s``
target_file: (a pathlike object or string representing an existing
file)
Output template volume
argument: ``--targ %s``
mutually_exclusive: target_file, tal, fs_target
tal: (a boolean)
map to a sub FOV of MNI305 (with --reg only)
argument: ``--tal``
mutually_exclusive: target_file, tal, fs_target
fs_target: (a boolean)
use orig.mgz from subject in regfile as target
argument: ``--fstarg``
mutually_exclusive: target_file, tal, fs_target
requires: reg_file
reg_file: (a pathlike object or string representing an existing file)
tkRAS-to-tkRAS matrix (tkregister2 format)
argument: ``--reg %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
lta_file: (a pathlike object or string representing an existing file)
Linear Transform Array file
argument: ``--lta %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
lta_inv_file: (a pathlike object or string representing an existing
file)
LTA, invert
argument: ``--lta-inv %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
fsl_reg_file: (a pathlike object or string representing an existing
file)
fslRAS-to-fslRAS matrix (FSL format)
argument: ``--fsl %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
xfm_reg_file: (a pathlike object or string representing an existing
file)
ScannerRAS-to-ScannerRAS matrix (MNI format)
argument: ``--xfm %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
reg_header: (a boolean)
ScannerRAS-to-ScannerRAS matrix = identity
argument: ``--regheader``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
mni_152_reg: (a boolean)
target MNI152 space
argument: ``--regheader``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
subject: (a unicode string)
set matrix = identity and use subject for any templates
argument: ``--s %s``
mutually_exclusive: reg_file, lta_file, lta_inv_file, fsl_reg_file,
xfm_reg_file, reg_header, mni_152_reg, subject
[Optional]
transformed_file: (a pathlike object or string representing a file)
Output volume
argument: ``--o %s``
tal_resolution: (a float)
Resolution to sample when using tal
argument: ``--talres %.10f``
inverse: (a boolean)
sample from target to source
argument: ``--inv``
interp: ('trilin' or 'nearest' or 'cubic')
Interpolation method (<trilin> or nearest)
argument: ``--interp %s``
no_resample: (a boolean)
Do not resample; just change vox2ras matrix
argument: ``--no-resample``
m3z_file: (a pathlike object or string representing a file)
This is the morph to be applied to the volume. Unless the morph is
in mri/transforms (eg.: for talairach.m3z computed by reconall), you
will need to specify the full path to this morph and use the
--noDefM3zPath flag.
argument: ``--m3z %s``
no_ded_m3z_path: (a boolean)
To be used with the m3z flag. Instructs the code not to look for
them3z morph in the default location
(SUBJECTS_DIR/subj/mri/transforms), but instead just use the path
indicated in --m3z.
argument: ``--noDefM3zPath``
requires: m3z_file
invert_morph: (a boolean)
Compute and use the inverse of the non-linear morph to resample the
input volume. To be used by --m3z.
argument: ``--inv-morph``
requires: m3z_file
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
transformed_file: (a pathlike object or string representing an
existing file)
Path to output file if used normally
BBRegister¶
Wraps the executable command bbregister.
Use FreeSurfer bbregister to register a volume to the Freesurfer anatomical.
This program performs within-subject, cross-modal registration using a boundary-based cost function. It is required that you have an anatomical scan of the subject that has already been recon-all-ed using freesurfer.
Examples¶
>>> from nipype.interfaces.freesurfer import BBRegister
>>> bbreg = BBRegister(subject_id='me', source_file='structural.nii', init='header', contrast_type='t2')
>>> bbreg.cmdline
'bbregister --t2 --init-header --reg structural_bbreg_me.dat --mov structural.nii --s me'
Inputs:
[Mandatory]
subject_id: (a unicode string)
freesurfer subject id
argument: ``--s %s``
source_file: (a pathlike object or string representing a file)
source file to be registered
argument: ``--mov %s``
contrast_type: ('t1' or 't2' or 'bold' or 'dti')
contrast type of image
argument: ``--%s``
[Optional]
init: ('coreg' or 'rr' or 'spm' or 'fsl' or 'header' or 'best')
initialize registration with mri_coreg, spm, fsl, or header
argument: ``--init-%s``
mutually_exclusive: init_reg_file
init_reg_file: (a pathlike object or string representing an existing
file)
existing registration file
argument: ``--init-reg %s``
mutually_exclusive: init
intermediate_file: (a pathlike object or string representing an
existing file)
Intermediate image, e.g. in case of partial FOV
argument: ``--int %s``
reg_frame: (an integer (int or long))
0-based frame index for 4D source file
argument: ``--frame %d``
mutually_exclusive: reg_middle_frame
reg_middle_frame: (a boolean)
Register middle frame of 4D source file
argument: ``--mid-frame``
mutually_exclusive: reg_frame
out_reg_file: (a pathlike object or string representing a file)
output registration file
argument: ``--reg %s``
spm_nifti: (a boolean)
force use of nifti rather than analyze with SPM
argument: ``--spm-nii``
epi_mask: (a boolean)
mask out B0 regions in stages 1 and 2
argument: ``--epi-mask``
dof: (6 or 9 or 12)
number of transform degrees of freedom
argument: ``--%d``
fsldof: (an integer (int or long))
degrees of freedom for initial registration (FSL)
argument: ``--fsl-dof %d``
out_fsl_file: (a boolean or a pathlike object or string representing
a file)
write the transformation matrix in FSL FLIRT format
argument: ``--fslmat %s``
out_lta_file: (a boolean or a pathlike object or string representing
a file)
write the transformation matrix in LTA format
argument: ``--lta %s``
registered_file: (a boolean or a pathlike object or string
representing a file)
output warped sourcefile either True or filename
argument: ``--o %s``
init_cost_file: (a boolean or a pathlike object or string
representing a file)
output initial registration cost file
argument: ``--initcost %s``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_reg_file: (a pathlike object or string representing an existing
file)
Output registration file
out_fsl_file: (a pathlike object or string representing an existing
file)
Output FLIRT-style registration file
out_lta_file: (a pathlike object or string representing an existing
file)
Output LTA-style registration file
min_cost_file: (a pathlike object or string representing an existing
file)
Output registration minimum cost file
init_cost_file: (a pathlike object or string representing an existing
file)
Output initial registration cost file
registered_file: (a pathlike object or string representing an
existing file)
Registered and resampled source file
CALabel¶
Wraps the executable command mri_ca_label.
For complete details, see the FS Documentation
Examples¶
>>> from nipype.interfaces import freesurfer
>>> ca_label = freesurfer.CALabel()
>>> ca_label.inputs.in_file = "norm.mgz"
>>> ca_label.inputs.out_file = "out.mgz"
>>> ca_label.inputs.transform = "trans.mat"
>>> ca_label.inputs.template = "Template_6.nii" # in practice use .gcs extension
>>> ca_label.cmdline
'mri_ca_label norm.mgz trans.mat Template_6.nii out.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
Input volume for CALabel
argument: ``%s``, position: -4
out_file: (a pathlike object or string representing a file)
Output file for CALabel
argument: ``%s``, position: -1
transform: (a pathlike object or string representing an existing
file)
Input transform for CALabel
argument: ``%s``, position: -3
template: (a pathlike object or string representing an existing file)
Input template for CALabel
argument: ``%s``, position: -2
[Optional]
in_vol: (a pathlike object or string representing an existing file)
set input volume
argument: ``-r %s``
intensities: (a pathlike object or string representing an existing
file)
input label intensities file(used in longitudinal processing)
argument: ``-r %s``
no_big_ventricles: (a boolean)
No big ventricles
argument: ``-nobigventricles``
align: (a boolean)
Align CALabel
argument: ``-align``
prior: (a float)
Prior for CALabel
argument: ``-prior %.1f``
relabel_unlikely: (a tuple of the form: (an integer (int or long), a
float))
Reclassify voxels at least some std devs from the mean using some
size Gaussian window
argument: ``-relabel_unlikely %d %.1f``
label: (a pathlike object or string representing an existing file)
Undocumented flag. Autorecon3 uses
../label/{hemisphere}.cortex.label as input file
argument: ``-l %s``
aseg: (a pathlike object or string representing an existing file)
Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input
file
argument: ``-aseg %s``
num_threads: (an integer (int or long))
allows for specifying more threads
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
Output volume from CALabel
CANormalize¶
Wraps the executable command mri_ca_normalize.
This program creates a normalized volume using the brain volume and an input gca file.
For complete details, see the FS Documentation
Examples¶
>>> from nipype.interfaces import freesurfer
>>> ca_normalize = freesurfer.CANormalize()
>>> ca_normalize.inputs.in_file = "T1.mgz"
>>> ca_normalize.inputs.atlas = "atlas.nii.gz" # in practice use .gca atlases
>>> ca_normalize.inputs.transform = "trans.mat" # in practice use .lta transforms
>>> ca_normalize.cmdline
'mri_ca_normalize T1.mgz atlas.nii.gz trans.mat T1_norm.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
The input file for CANormalize
argument: ``%s``, position: -4
atlas: (a pathlike object or string representing an existing file)
The atlas file in gca format
argument: ``%s``, position: -3
transform: (a pathlike object or string representing an existing
file)
The tranform file in lta format
argument: ``%s``, position: -2
[Optional]
out_file: (a pathlike object or string representing a file)
The output file for CANormalize
argument: ``%s``, position: -1
mask: (a pathlike object or string representing an existing file)
Specifies volume to use as mask
argument: ``-mask %s``
control_points: (a pathlike object or string representing a file)
File name for the output control points
argument: ``-c %s``
long_file: (a pathlike object or string representing a file)
undocumented flag used in longitudinal processing
argument: ``-long %s``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
The output file for Normalize
control_points: (a pathlike object or string representing a file)
The output control points for Normalize
CARegister¶
Wraps the executable command mri_ca_register.
Generates a multi-dimensional talairach transform from a gca file and talairach.lta file
For complete details, see the FS Documentation
Examples¶
>>> from nipype.interfaces import freesurfer
>>> ca_register = freesurfer.CARegister()
>>> ca_register.inputs.in_file = "norm.mgz"
>>> ca_register.inputs.out_file = "talairach.m3z"
>>> ca_register.cmdline
'mri_ca_register norm.mgz talairach.m3z'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
The input volume for CARegister
argument: ``%s``, position: -3
[Optional]
out_file: (a pathlike object or string representing a file)
The output volume for CARegister
argument: ``%s``, position: -1
template: (a pathlike object or string representing an existing file)
The template file in gca format
argument: ``%s``, position: -2
mask: (a pathlike object or string representing an existing file)
Specifies volume to use as mask
argument: ``-mask %s``
invert_and_save: (a boolean)
Invert and save the .m3z multi-dimensional talaraich transform to x,
y, and z .mgz files
argument: ``-invert-and-save``, position: -4
no_big_ventricles: (a boolean)
No big ventricles
argument: ``-nobigventricles``
transform: (a pathlike object or string representing an existing
file)
Specifies transform in lta format
argument: ``-T %s``
align: (a string)
Specifies when to perform alignment
argument: ``-align-%s``
levels: (an integer (int or long))
defines how many surrounding voxels will be used in interpolations,
default is 6
argument: ``-levels %d``
A: (an integer (int or long))
undocumented flag used in longitudinal processing
argument: ``-A %d``
l_files: (a list of items which are a pathlike object or string
representing a file)
undocumented flag used in longitudinal processing
argument: ``-l %s``
num_threads: (an integer (int or long))
allows for specifying more threads
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
The output file for CARegister
ConcatenateLTA¶
Wraps the executable command mri_concatenate_lta.
Concatenates two consecutive LTA transformations into one overall transformation
Out = LTA2*LTA1
Examples¶
>>> from nipype.interfaces.freesurfer import ConcatenateLTA
>>> conc_lta = ConcatenateLTA()
>>> conc_lta.inputs.in_lta1 = 'lta1.lta'
>>> conc_lta.inputs.in_lta2 = 'lta2.lta'
>>> conc_lta.cmdline
'mri_concatenate_lta lta1.lta lta2.lta lta1_concat.lta'
You can use ‘identity.nofile’ as the filename for in_lta2, e.g.:
>>> conc_lta.inputs.in_lta2 = 'identity.nofile'
>>> conc_lta.inputs.invert_1 = True
>>> conc_lta.inputs.out_file = 'inv1.lta'
>>> conc_lta.cmdline
'mri_concatenate_lta -invert1 lta1.lta identity.nofile inv1.lta'
To create a RAS2RAS transform:
>>> conc_lta.inputs.out_type = 'RAS2RAS'
>>> conc_lta.cmdline
'mri_concatenate_lta -invert1 -out_type 1 lta1.lta identity.nofile inv1.lta'
Inputs:
[Mandatory]
in_lta1: (a pathlike object or string representing an existing file)
maps some src1 to dst1
argument: ``%s``, position: -3
in_lta2: (a pathlike object or string representing an existing file
or 'identity.nofile')
maps dst1(src2) to dst2
argument: ``%s``, position: -2
[Optional]
out_file: (a pathlike object or string representing a file)
the combined LTA maps: src1 to dst2 = LTA2*LTA1
argument: ``%s``, position: -1
invert_1: (a boolean)
invert in_lta1 before applying it
argument: ``-invert1``
invert_2: (a boolean)
invert in_lta2 before applying it
argument: ``-invert2``
invert_out: (a boolean)
invert output LTA
argument: ``-invertout``
out_type: ('VOX2VOX' or 'RAS2RAS')
set final LTA type
argument: ``-out_type %d``
tal_source_file: (a pathlike object or string representing an
existing file)
if in_lta2 is talairach.xfm, specify source for talairach
argument: ``-tal %s``, position: -5
requires: tal_template_file
tal_template_file: (a pathlike object or string representing an
existing file)
if in_lta2 is talairach.xfm, specify template for talairach
argument: ``%s``, position: -4
requires: tal_source_file
subject: (a unicode string)
set subject in output LTA
argument: ``-subject %s``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
the combined LTA maps: src1 to dst2 = LTA2*LTA1
DICOMConvert¶
Wraps the executable command mri_convert.
use fs mri_convert to convert dicom files
Examples¶
>>> from nipype.interfaces.freesurfer import DICOMConvert
>>> cvt = DICOMConvert()
>>> cvt.inputs.dicom_dir = 'dicomdir'
>>> cvt.inputs.file_mapping = [('nifti', '*.nii'), ('info', 'dicom*.txt'), ('dti', '*dti.bv*')]
Inputs:
[Mandatory]
dicom_dir: (a pathlike object or string representing an existing
directory)
dicom directory from which to convert dicom files
base_output_dir: (a pathlike object or string representing a
directory)
directory in which subject directories are created
[Optional]
subject_dir_template: (a unicode string, nipype default value:
S.%04d)
template for subject directory name
subject_id: (any value)
subject identifier to insert into template
file_mapping: (a list of items which are a tuple of the form: (a
unicode string, a unicode string))
defines the output fields of interface
out_type: ('cor' or 'mgh' or 'mgz' or 'minc' or 'analyze' or
'analyze4d' or 'spm' or 'afni' or 'brik' or 'bshort' or 'bfloat'
or 'sdt' or 'outline' or 'otl' or 'gdf' or 'nifti1' or 'nii' or
'niigz', nipype default value: niigz)
defines the type of output file produced
dicom_info: (a pathlike object or string representing an existing
file)
File containing summary information from mri_parse_sdcmdir
seq_list: (a list of items which are a unicode string)
list of pulse sequence names to be converted.
requires: dicom_info
ignore_single_slice: (a boolean)
ignore volumes containing a single slice
requires: dicom_info
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
None
EditWMwithAseg¶
Wraps the executable command mri_edit_wm_with_aseg.
Edits a wm file using a segmentation
Examples¶
>>> from nipype.interfaces.freesurfer import EditWMwithAseg
>>> editwm = EditWMwithAseg()
>>> editwm.inputs.in_file = "T1.mgz"
>>> editwm.inputs.brain_file = "norm.mgz"
>>> editwm.inputs.seg_file = "aseg.mgz"
>>> editwm.inputs.out_file = "wm.asegedit.mgz"
>>> editwm.inputs.keep_in = True
>>> editwm.cmdline
'mri_edit_wm_with_aseg -keep-in T1.mgz norm.mgz aseg.mgz wm.asegedit.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
Input white matter segmentation file
argument: ``%s``, position: -4
brain_file: (a pathlike object or string representing an existing
file)
Input brain/T1 file
argument: ``%s``, position: -3
seg_file: (a pathlike object or string representing an existing file)
Input presurf segmentation file
argument: ``%s``, position: -2
out_file: (a pathlike object or string representing a file)
File to be written as output
argument: ``%s``, position: -1
[Optional]
keep_in: (a boolean)
Keep edits as found in input volume
argument: ``-keep-in``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
Output edited WM file
FitMSParams¶
Wraps the executable command mri_ms_fitparms.
Estimate tissue paramaters from a set of FLASH images.
Examples¶
>>> from nipype.interfaces.freesurfer import FitMSParams
>>> msfit = FitMSParams()
>>> msfit.inputs.in_files = ['flash_05.mgz', 'flash_30.mgz']
>>> msfit.inputs.out_dir = 'flash_parameters'
>>> msfit.cmdline
'mri_ms_fitparms flash_05.mgz flash_30.mgz flash_parameters'
Inputs:
[Mandatory]
in_files: (a list of items which are a pathlike object or string
representing an existing file)
list of FLASH images (must be in mgh format)
argument: ``%s``, position: -2
[Optional]
tr_list: (a list of items which are an integer (int or long))
list of TRs of the input files (in msec)
te_list: (a list of items which are a float)
list of TEs of the input files (in msec)
flip_list: (a list of items which are an integer (int or long))
list of flip angles of the input files
xfm_list: (a list of items which are a pathlike object or string
representing an existing file)
list of transform files to apply to each FLASH image
out_dir: (a pathlike object or string representing a directory)
directory to store output in
argument: ``%s``, position: -1
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
t1_image: (a pathlike object or string representing an existing file)
image of estimated T1 relaxation values
pd_image: (a pathlike object or string representing an existing file)
image of estimated proton density values
t2star_image: (a pathlike object or string representing an existing
file)
image of estimated T2* values
MNIBiasCorrection¶
Wraps the executable command mri_nu_correct.mni.
Wrapper for nu_correct, a program from the Montreal Neurological Insitute (MNI) used for correcting intensity non-uniformity (ie, bias fields). You must have the MNI software installed on your system to run this. See [www.bic.mni.mcgill.ca/software/N3] for more info.
mri_nu_correct.mni uses float internally instead of uchar. It also rescales the output so that the global mean is the same as that of the input. These two changes are linked and can be turned off with –no-float
Examples¶
>>> from nipype.interfaces.freesurfer import MNIBiasCorrection
>>> correct = MNIBiasCorrection()
>>> correct.inputs.in_file = "norm.mgz"
>>> correct.inputs.iterations = 6
>>> correct.inputs.protocol_iterations = 1000
>>> correct.inputs.distance = 50
>>> correct.cmdline
'mri_nu_correct.mni --distance 50 --i norm.mgz --n 6 --o norm_output.mgz --proto-iters 1000'
References:¶
[http://freesurfer.net/fswiki/mri_nu_correct.mni] [http://www.bic.mni.mcgill.ca/software/N3] [https://github.com/BIC-MNI/N3]
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
input volume. Input can be any format accepted by mri_convert.
argument: ``--i %s``
[Optional]
out_file: (a pathlike object or string representing a file)
output volume. Output can be any format accepted by mri_convert. If
the output format is COR, then the directory must exist.
argument: ``--o %s``
iterations: (an integer (int or long), nipype default value: 4)
Number of iterations to run nu_correct. Default is 4. This is the
number of times that nu_correct is repeated (ie, using the output
from the previous run as the input for the next). This is different
than the -iterations option to nu_correct.
argument: ``--n %d``
protocol_iterations: (an integer (int or long))
Passes Np as argument of the -iterations flag of nu_correct. This is
different than the --n flag above. Default is not to pass nu_correct
the -iterations flag.
argument: ``--proto-iters %d``
distance: (an integer (int or long))
N3 -distance option
argument: ``--distance %d``
no_rescale: (a boolean)
do not rescale so that global mean of output == input global mean
argument: ``--no-rescale``
mask: (a pathlike object or string representing an existing file)
brainmask volume. Input can be any format accepted by mri_convert.
argument: ``--mask %s``
transform: (a pathlike object or string representing an existing
file)
tal.xfm. Use mri_make_uchar instead of conforming
argument: ``--uchar %s``
stop: (a float)
Convergence threshold below which iteration stops (suggest 0.01 to
0.0001)
argument: ``--stop %f``
shrink: (an integer (int or long))
Shrink parameter for finer sampling (default is 4)
argument: ``--shrink %d``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing an existing file)
output volume
MRIConvert¶
Wraps the executable command mri_convert.
use fs mri_convert to manipulate files
Note
Adds niigz as an output type option
Examples¶
>>> mc = MRIConvert()
>>> mc.inputs.in_file = 'structural.nii'
>>> mc.inputs.out_file = 'outfile.mgz'
>>> mc.inputs.out_type = 'mgz'
>>> mc.cmdline
'mri_convert --out_type mgz --input_volume structural.nii --output_volume outfile.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
File to read/convert
argument: ``--input_volume %s``, position: -2
[Optional]
read_only: (a boolean)
read the input volume
argument: ``--read_only``
no_write: (a boolean)
do not write output
argument: ``--no_write``
in_info: (a boolean)
display input info
argument: ``--in_info``
out_info: (a boolean)
display output info
argument: ``--out_info``
in_stats: (a boolean)
display input stats
argument: ``--in_stats``
out_stats: (a boolean)
display output stats
argument: ``--out_stats``
in_matrix: (a boolean)
display input matrix
argument: ``--in_matrix``
out_matrix: (a boolean)
display output matrix
argument: ``--out_matrix``
in_i_size: (an integer (int or long))
input i size
argument: ``--in_i_size %d``
in_j_size: (an integer (int or long))
input j size
argument: ``--in_j_size %d``
in_k_size: (an integer (int or long))
input k size
argument: ``--in_k_size %d``
force_ras: (a boolean)
use default when orientation info absent
argument: ``--force_ras_good``
in_i_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--in_i_direction %f %f %f``
in_j_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--in_j_direction %f %f %f``
in_k_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--in_k_direction %f %f %f``
in_orientation: ('LAI' or 'LIA' or 'ALI' or 'AIL' or 'ILA' or 'IAL'
or 'LAS' or 'LSA' or 'ALS' or 'ASL' or 'SLA' or 'SAL' or 'LPI' or
'LIP' or 'PLI' or 'PIL' or 'ILP' or 'IPL' or 'LPS' or 'LSP' or
'PLS' or 'PSL' or 'SLP' or 'SPL' or 'RAI' or 'RIA' or 'ARI' or
'AIR' or 'IRA' or 'IAR' or 'RAS' or 'RSA' or 'ARS' or 'ASR' or
'SRA' or 'SAR' or 'RPI' or 'RIP' or 'PRI' or 'PIR' or 'IRP' or
'IPR' or 'RPS' or 'RSP' or 'PRS' or 'PSR' or 'SRP' or 'SPR')
specify the input orientation
argument: ``--in_orientation %s``
in_center: (a list of at most 3 items which are a float)
<R coordinate> <A coordinate> <S coordinate>
argument: ``--in_center %s``
sphinx: (a boolean)
change orientation info to sphinx
argument: ``--sphinx``
out_i_count: (an integer (int or long))
some count ?? in i direction
argument: ``--out_i_count %d``
out_j_count: (an integer (int or long))
some count ?? in j direction
argument: ``--out_j_count %d``
out_k_count: (an integer (int or long))
some count ?? in k direction
argument: ``--out_k_count %d``
vox_size: (a tuple of the form: (a float, a float, a float))
<size_x> <size_y> <size_z> specify the size (mm) - useful for
upsampling or downsampling
argument: ``-voxsize %f %f %f``
out_i_size: (an integer (int or long))
output i size
argument: ``--out_i_size %d``
out_j_size: (an integer (int or long))
output j size
argument: ``--out_j_size %d``
out_k_size: (an integer (int or long))
output k size
argument: ``--out_k_size %d``
out_i_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--out_i_direction %f %f %f``
out_j_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--out_j_direction %f %f %f``
out_k_dir: (a tuple of the form: (a float, a float, a float))
<R direction> <A direction> <S direction>
argument: ``--out_k_direction %f %f %f``
out_orientation: ('LAI' or 'LIA' or 'ALI' or 'AIL' or 'ILA' or 'IAL'
or 'LAS' or 'LSA' or 'ALS' or 'ASL' or 'SLA' or 'SAL' or 'LPI' or
'LIP' or 'PLI' or 'PIL' or 'ILP' or 'IPL' or 'LPS' or 'LSP' or
'PLS' or 'PSL' or 'SLP' or 'SPL' or 'RAI' or 'RIA' or 'ARI' or
'AIR' or 'IRA' or 'IAR' or 'RAS' or 'RSA' or 'ARS' or 'ASR' or
'SRA' or 'SAR' or 'RPI' or 'RIP' or 'PRI' or 'PIR' or 'IRP' or
'IPR' or 'RPS' or 'RSP' or 'PRS' or 'PSR' or 'SRP' or 'SPR')
specify the output orientation
argument: ``--out_orientation %s``
out_center: (a tuple of the form: (a float, a float, a float))
<R coordinate> <A coordinate> <S coordinate>
argument: ``--out_center %f %f %f``
out_datatype: ('uchar' or 'short' or 'int' or 'float')
output data type <uchar|short|int|float>
argument: ``--out_data_type %s``
resample_type: ('interpolate' or 'weighted' or 'nearest' or 'sinc' or
'cubic')
<interpolate|weighted|nearest|sinc|cubic> (default is interpolate)
argument: ``--resample_type %s``
no_scale: (a boolean)
dont rescale values for COR
argument: ``--no_scale 1``
no_change: (a boolean)
don't change type of input to that of template
argument: ``--nochange``
tr: (an integer (int or long))
TR in msec
argument: ``-tr %d``
te: (an integer (int or long))
TE in msec
argument: ``-te %d``
ti: (an integer (int or long))
TI in msec (note upper case flag)
argument: ``-ti %d``
autoalign_matrix: (a pathlike object or string representing an
existing file)
text file with autoalign matrix
argument: ``--autoalign %s``
unwarp_gradient: (a boolean)
unwarp gradient nonlinearity
argument: ``--unwarp_gradient_nonlinearity``
apply_transform: (a pathlike object or string representing an
existing file)
apply xfm file
argument: ``--apply_transform %s``
apply_inv_transform: (a pathlike object or string representing an
existing file)
apply inverse transformation xfm file
argument: ``--apply_inverse_transform %s``
devolve_transform: (a unicode string)
subject id
argument: ``--devolvexfm %s``
crop_center: (a tuple of the form: (an integer (int or long), an
integer (int or long), an integer (int or long)))
<x> <y> <z> crop to 256 around center (x, y, z)
argument: ``--crop %d %d %d``
crop_size: (a tuple of the form: (an integer (int or long), an
integer (int or long), an integer (int or long)))
<dx> <dy> <dz> crop to size <dx, dy, dz>
argument: ``--cropsize %d %d %d``
cut_ends: (an integer (int or long))
remove ncut slices from the ends
argument: ``--cutends %d``
slice_crop: (a tuple of the form: (an integer (int or long), an
integer (int or long)))
s_start s_end : keep slices s_start to s_end
argument: ``--slice-crop %d %d``
slice_reverse: (a boolean)
reverse order of slices, update vox2ras
argument: ``--slice-reverse``
slice_bias: (a float)
apply half-cosine bias field
argument: ``--slice-bias %f``
fwhm: (a float)
smooth input volume by fwhm mm
argument: ``--fwhm %f``
in_type: ('cor' or 'mgh' or 'mgz' or 'minc' or 'analyze' or
'analyze4d' or 'spm' or 'afni' or 'brik' or 'bshort' or 'bfloat'
or 'sdt' or 'outline' or 'otl' or 'gdf' or 'nifti1' or 'nii' or
'niigz' or 'ge' or 'gelx' or 'lx' or 'ximg' or 'siemens' or
'dicom' or 'siemens_dicom')
input file type
argument: ``--in_type %s``
out_type: ('cor' or 'mgh' or 'mgz' or 'minc' or 'analyze' or
'analyze4d' or 'spm' or 'afni' or 'brik' or 'bshort' or 'bfloat'
or 'sdt' or 'outline' or 'otl' or 'gdf' or 'nifti1' or 'nii' or
'niigz')
output file type
argument: ``--out_type %s``
ascii: (a boolean)
save output as ascii col>row>slice>frame
argument: ``--ascii``
reorder: (a tuple of the form: (an integer (int or long), an integer
(int or long), an integer (int or long)))
olddim1 olddim2 olddim3
argument: ``--reorder %d %d %d``
invert_contrast: (a float)
threshold for inversting contrast
argument: ``--invert_contrast %f``
out_file: (a pathlike object or string representing a file)
output filename or True to generate one
argument: ``--output_volume %s``, position: -1
conform: (a boolean)
conform to 1mm voxel size in coronal slice direction with 256^3 or
more
argument: ``--conform``
conform_min: (a boolean)
conform to smallest size
argument: ``--conform_min``
conform_size: (a float)
conform to size_in_mm
argument: ``--conform_size %s``
cw256: (a boolean)
confrom to dimensions of 256^3
argument: ``--cw256``
parse_only: (a boolean)
parse input only
argument: ``--parse_only``
subject_name: (a unicode string)
subject name ???
argument: ``--subject_name %s``
reslice_like: (a pathlike object or string representing an existing
file)
reslice output to match file
argument: ``--reslice_like %s``
template_type: ('cor' or 'mgh' or 'mgz' or 'minc' or 'analyze' or
'analyze4d' or 'spm' or 'afni' or 'brik' or 'bshort' or 'bfloat'
or 'sdt' or 'outline' or 'otl' or 'gdf' or 'nifti1' or 'nii' or
'niigz' or 'ge' or 'gelx' or 'lx' or 'ximg' or 'siemens' or
'dicom' or 'siemens_dicom')
template file type
argument: ``--template_type %s``
split: (a boolean)
split output frames into separate output files.
argument: ``--split``
frame: (an integer (int or long))
keep only 0-based frame number
argument: ``--frame %d``
midframe: (a boolean)
keep only the middle frame
argument: ``--mid-frame``
skip_n: (an integer (int or long))
skip the first n frames
argument: ``--nskip %d``
drop_n: (an integer (int or long))
drop the last n frames
argument: ``--ndrop %d``
frame_subsample: (a tuple of the form: (an integer (int or long), an
integer (int or long), an integer (int or long)))
start delta end : frame subsampling (end = -1 for end)
argument: ``--fsubsample %d %d %d``
in_scale: (a float)
input intensity scale factor
argument: ``--scale %f``
out_scale: (a float)
output intensity scale factor
argument: ``--out-scale %d``
in_like: (a pathlike object or string representing an existing file)
input looks like
argument: ``--in_like %s``
fill_parcellation: (a boolean)
fill parcellation
argument: ``--fill_parcellation``
smooth_parcellation: (a boolean)
smooth parcellation
argument: ``--smooth_parcellation``
zero_outlines: (a boolean)
zero outlines
argument: ``--zero_outlines``
color_file: (a pathlike object or string representing an existing
file)
color file
argument: ``--color_file %s``
no_translate: (a boolean)
~~~
argument: ``--no_translate``
status_file: (a pathlike object or string representing a file)
status file for DICOM conversion
argument: ``--status %s``
sdcm_list: (a pathlike object or string representing an existing
file)
list of DICOM files for conversion
argument: ``--sdcmlist %s``
template_info: (a boolean)
dump info about template
argument: ``--template_info``
crop_gdf: (a boolean)
apply GDF cropping
argument: ``--crop_gdf``
zero_ge_z_offset: (a boolean)
zero ge z offset ???
argument: ``--zero_ge_z_offset``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a list of items which are a pathlike object or string
representing an existing file)
converted output file
MRIsCALabel¶
Wraps the executable command mris_ca_label.
For a single subject, produces an annotation file, in which each cortical surface vertex is assigned a neuroanatomical label.This automatic procedure employs data from a previously-prepared atlas file. An atlas file is created from a training set, capturing region data manually drawn by neuroanatomists combined with statistics on variability correlated to geometric information derived from the cortical model (sulcus and curvature). Besides the atlases provided with FreeSurfer, new ones can be prepared using mris_ca_train).
Examples¶
>>> from nipype.interfaces import freesurfer
>>> ca_label = freesurfer.MRIsCALabel()
>>> ca_label.inputs.subject_id = "test"
>>> ca_label.inputs.hemisphere = "lh"
>>> ca_label.inputs.canonsurf = "lh.pial"
>>> ca_label.inputs.curv = "lh.pial"
>>> ca_label.inputs.sulc = "lh.pial"
>>> ca_label.inputs.classifier = "im1.nii" # in pracice, use .gcs extension
>>> ca_label.inputs.smoothwm = "lh.pial"
>>> ca_label.cmdline
'mris_ca_label test lh lh.pial im1.nii lh.aparc.annot'
Inputs:
[Mandatory]
subject_id: (a string, nipype default value: subject_id)
Subject name or ID
argument: ``%s``, position: -5
hemisphere: ('lh' or 'rh')
Hemisphere ('lh' or 'rh')
argument: ``%s``, position: -4
canonsurf: (a pathlike object or string representing an existing
file)
Input canonical surface file
argument: ``%s``, position: -3
classifier: (a pathlike object or string representing an existing
file)
Classifier array input file
argument: ``%s``, position: -2
smoothwm: (a pathlike object or string representing an existing file)
implicit input {hemisphere}.smoothwm
curv: (a pathlike object or string representing an existing file)
implicit input {hemisphere}.curv
sulc: (a pathlike object or string representing an existing file)
implicit input {hemisphere}.sulc
[Optional]
out_file: (a pathlike object or string representing a file)
Annotated surface output file
argument: ``%s``, position: -1
label: (a pathlike object or string representing an existing file)
Undocumented flag. Autorecon3 uses
../label/{hemisphere}.cortex.label as input file
argument: ``-l %s``
aseg: (a pathlike object or string representing an existing file)
Undocumented flag. Autorecon3 uses ../mri/aseg.presurf.mgz as input
file
argument: ``-aseg %s``
seed: (an integer (int or long))
argument: ``-seed %d``
copy_inputs: (a boolean)
Copies implicit inputs to node directory and creates a temp
subjects_directory. Use this when running as a node
num_threads: (an integer (int or long))
allows for specifying more threads
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
Output volume from MRIsCALabel
Normalize¶
Wraps the executable command mri_normalize.
Normalize the white-matter, optionally based on control points. The input volume is converted into a new volume where white matter image values all range around 110.
Examples¶
>>> from nipype.interfaces import freesurfer
>>> normalize = freesurfer.Normalize()
>>> normalize.inputs.in_file = "T1.mgz"
>>> normalize.inputs.gradient = 1
>>> normalize.cmdline
'mri_normalize -g 1 T1.mgz T1_norm.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
The input file for Normalize
argument: ``%s``, position: -2
[Optional]
out_file: (a pathlike object or string representing a file)
The output file for Normalize
argument: ``%s``, position: -1
gradient: (an integer (int or long))
use max intensity/mm gradient g (default=1)
argument: ``-g %d``
mask: (a pathlike object or string representing an existing file)
The input mask file for Normalize
argument: ``-mask %s``
segmentation: (a pathlike object or string representing an existing
file)
The input segmentation for Normalize
argument: ``-aseg %s``
transform: (a pathlike object or string representing an existing
file)
Tranform file from the header of the input file
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
The output file for Normalize
ParseDICOMDir¶
Wraps the executable command mri_parse_sdcmdir.
Uses mri_parse_sdcmdir to get information from dicom directories
Examples¶
>>> from nipype.interfaces.freesurfer import ParseDICOMDir
>>> dcminfo = ParseDICOMDir()
>>> dcminfo.inputs.dicom_dir = '.'
>>> dcminfo.inputs.sortbyrun = True
>>> dcminfo.inputs.summarize = True
>>> dcminfo.cmdline
'mri_parse_sdcmdir --d . --o dicominfo.txt --sortbyrun --summarize'
Inputs:
[Mandatory]
dicom_dir: (a pathlike object or string representing an existing
directory)
path to siemens dicom directory
argument: ``--d %s``
[Optional]
dicom_info_file: (a pathlike object or string representing a file,
nipype default value: dicominfo.txt)
file to which results are written
argument: ``--o %s``
sortbyrun: (a boolean)
assign run numbers
argument: ``--sortbyrun``
summarize: (a boolean)
only print out info for run leaders
argument: ``--summarize``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
dicom_info_file: (a pathlike object or string representing an
existing file)
text file containing dicom information
ReconAll¶
Wraps the executable command recon-all.
Uses recon-all to generate surfaces and parcellations of structural data from anatomical images of a subject.
Examples¶
>>> from nipype.interfaces.freesurfer import ReconAll
>>> reconall = ReconAll()
>>> reconall.inputs.subject_id = 'foo'
>>> reconall.inputs.directive = 'all'
>>> reconall.inputs.subjects_dir = '.'
>>> reconall.inputs.T1_files = 'structural.nii'
>>> reconall.cmdline
'recon-all -all -i structural.nii -subjid foo -sd .'
>>> reconall.inputs.flags = "-qcache"
>>> reconall.cmdline
'recon-all -all -i structural.nii -qcache -subjid foo -sd .'
>>> reconall.inputs.flags = ["-cw256", "-qcache"]
>>> reconall.cmdline
'recon-all -all -i structural.nii -cw256 -qcache -subjid foo -sd .'
Hemisphere may be specified regardless of directive:
>>> reconall.inputs.flags = []
>>> reconall.inputs.hemi = 'lh'
>>> reconall.cmdline
'recon-all -all -i structural.nii -hemi lh -subjid foo -sd .'
-autorecon-hemi uses the -hemi input to specify the hemisphere
to operate upon:
>>> reconall.inputs.directive = 'autorecon-hemi'
>>> reconall.cmdline
'recon-all -autorecon-hemi lh -i structural.nii -subjid foo -sd .'
Hippocampal subfields can accept T1 and T2 images:
>>> reconall_subfields = ReconAll()
>>> reconall_subfields.inputs.subject_id = 'foo'
>>> reconall_subfields.inputs.directive = 'all'
>>> reconall_subfields.inputs.subjects_dir = '.'
>>> reconall_subfields.inputs.T1_files = 'structural.nii'
>>> reconall_subfields.inputs.hippocampal_subfields_T1 = True
>>> reconall_subfields.cmdline
'recon-all -all -i structural.nii -hippocampal-subfields-T1 -subjid foo -sd .'
>>> reconall_subfields.inputs.hippocampal_subfields_T2 = (
... 'structural.nii', 'test')
>>> reconall_subfields.cmdline
'recon-all -all -i structural.nii -hippocampal-subfields-T1T2 structural.nii test -subjid foo -sd .'
>>> reconall_subfields.inputs.hippocampal_subfields_T1 = False
>>> reconall_subfields.cmdline
'recon-all -all -i structural.nii -hippocampal-subfields-T2 structural.nii test -subjid foo -sd .'
Inputs:
[Optional]
subject_id: (a unicode string, nipype default value: recon_all)
subject name
argument: ``-subjid %s``
directive: ('all' or 'autorecon1' or 'autorecon2' or
'autorecon2-volonly' or 'autorecon2-perhemi' or
'autorecon2-inflate1' or 'autorecon2-cp' or 'autorecon2-wm' or
'autorecon3' or 'autorecon3-T2pial' or 'autorecon-pial' or
'autorecon-hemi' or 'localGI' or 'qcache', nipype default value:
all)
process directive
argument: ``-%s``, position: 0
hemi: ('lh' or 'rh')
hemisphere to process
argument: ``-hemi %s``
T1_files: (a list of items which are a pathlike object or string
representing an existing file)
name of T1 file to process
argument: ``-i %s...``
T2_file: (a pathlike object or string representing an existing file)
Convert T2 image to orig directory
argument: ``-T2 %s``
FLAIR_file: (a pathlike object or string representing an existing
file)
Convert FLAIR image to orig directory
argument: ``-FLAIR %s``
use_T2: (a boolean)
Use T2 image to refine the pial surface
argument: ``-T2pial``
mutually_exclusive: use_FLAIR
use_FLAIR: (a boolean)
Use FLAIR image to refine the pial surface
argument: ``-FLAIRpial``
mutually_exclusive: use_T2
openmp: (an integer (int or long))
Number of processors to use in parallel
argument: ``-openmp %d``
parallel: (a boolean)
Enable parallel execution
argument: ``-parallel``
hires: (a boolean)
Conform to minimum voxel size (for voxels < 1mm)
argument: ``-hires``
mprage: (a boolean)
Assume scan parameters are MGH MP-RAGE protocol, which produces
darker gray matter
argument: ``-mprage``
big_ventricles: (a boolean)
For use in subjects with enlarged ventricles
argument: ``-bigventricles``
brainstem: (a boolean)
Segment brainstem structures
argument: ``-brainstem-structures``
hippocampal_subfields_T1: (a boolean)
segment hippocampal subfields using input T1 scan
argument: ``-hippocampal-subfields-T1``
hippocampal_subfields_T2: (a tuple of the form: (a pathlike object or
string representing an existing file, a unicode string))
segment hippocampal subfields using T2 scan, identified by ID (may
be combined with hippocampal_subfields_T1)
argument: ``-hippocampal-subfields-T2 %s %s``
expert: (a pathlike object or string representing an existing file)
Set parameters using expert file
argument: ``-expert %s``
xopts: ('use' or 'clean' or 'overwrite')
Use, delete or overwrite existing expert options file
argument: ``-xopts-%s``
subjects_dir: (a pathlike object or string representing an existing
directory)
path to subjects directory
argument: ``-sd %s``
flags: (a list of items which are a unicode string)
additional parameters
argument: ``%s``
talairach: (a unicode string)
Flags to pass to talairach commands
mutually_exclusive: expert
mri_normalize: (a unicode string)
Flags to pass to mri_normalize commands
mutually_exclusive: expert
mri_watershed: (a unicode string)
Flags to pass to mri_watershed commands
mutually_exclusive: expert
mri_em_register: (a unicode string)
Flags to pass to mri_em_register commands
mutually_exclusive: expert
mri_ca_normalize: (a unicode string)
Flags to pass to mri_ca_normalize commands
mutually_exclusive: expert
mri_ca_register: (a unicode string)
Flags to pass to mri_ca_register commands
mutually_exclusive: expert
mri_remove_neck: (a unicode string)
Flags to pass to mri_remove_neck commands
mutually_exclusive: expert
mri_ca_label: (a unicode string)
Flags to pass to mri_ca_label commands
mutually_exclusive: expert
mri_segstats: (a unicode string)
Flags to pass to mri_segstats commands
mutually_exclusive: expert
mri_mask: (a unicode string)
Flags to pass to mri_mask commands
mutually_exclusive: expert
mri_segment: (a unicode string)
Flags to pass to mri_segment commands
mutually_exclusive: expert
mri_edit_wm_with_aseg: (a unicode string)
Flags to pass to mri_edit_wm_with_aseg commands
mutually_exclusive: expert
mri_pretess: (a unicode string)
Flags to pass to mri_pretess commands
mutually_exclusive: expert
mri_fill: (a unicode string)
Flags to pass to mri_fill commands
mutually_exclusive: expert
mri_tessellate: (a unicode string)
Flags to pass to mri_tessellate commands
mutually_exclusive: expert
mris_smooth: (a unicode string)
Flags to pass to mri_smooth commands
mutually_exclusive: expert
mris_inflate: (a unicode string)
Flags to pass to mri_inflate commands
mutually_exclusive: expert
mris_sphere: (a unicode string)
Flags to pass to mris_sphere commands
mutually_exclusive: expert
mris_fix_topology: (a unicode string)
Flags to pass to mris_fix_topology commands
mutually_exclusive: expert
mris_make_surfaces: (a unicode string)
Flags to pass to mris_make_surfaces commands
mutually_exclusive: expert
mris_surf2vol: (a unicode string)
Flags to pass to mris_surf2vol commands
mutually_exclusive: expert
mris_register: (a unicode string)
Flags to pass to mris_register commands
mutually_exclusive: expert
mrisp_paint: (a unicode string)
Flags to pass to mrisp_paint commands
mutually_exclusive: expert
mris_ca_label: (a unicode string)
Flags to pass to mris_ca_label commands
mutually_exclusive: expert
mris_anatomical_stats: (a unicode string)
Flags to pass to mris_anatomical_stats commands
mutually_exclusive: expert
mri_aparc2aseg: (a unicode string)
Flags to pass to mri_aparc2aseg commands
mutually_exclusive: expert
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
subjects_dir: (a pathlike object or string representing an existing
directory)
Freesurfer subjects directory.
subject_id: (a unicode string)
Subject name for whom to retrieve data
T1: (a pathlike object or string representing an existing file)
Intensity normalized whole-head volume
aseg: (a pathlike object or string representing an existing file)
Volumetric map of regions from automatic segmentation
brain: (a pathlike object or string representing an existing file)
Intensity normalized brain-only volume
brainmask: (a pathlike object or string representing an existing
file)
Skull-stripped (brain-only) volume
filled: (a pathlike object or string representing an existing file)
Subcortical mass volume
norm: (a pathlike object or string representing an existing file)
Normalized skull-stripped volume
nu: (a pathlike object or string representing an existing file)
Non-uniformity corrected whole-head volume
orig: (a pathlike object or string representing an existing file)
Base image conformed to Freesurfer space
rawavg: (a pathlike object or string representing an existing file)
Volume formed by averaging input images
ribbon: (a list of items which are a pathlike object or string
representing an existing file)
Volumetric maps of cortical ribbons
wm: (a pathlike object or string representing an existing file)
Segmented white-matter volume
wmparc: (a pathlike object or string representing an existing file)
Aparc parcellation projected into subcortical white matter
curv: (a list of items which are a pathlike object or string
representing an existing file)
Maps of surface curvature
avg_curv: (a list of items which are a pathlike object or string
representing an existing file)
Average atlas curvature, sampled to subject
inflated: (a list of items which are a pathlike object or string
representing an existing file)
Inflated surface meshes
pial: (a list of items which are a pathlike object or string
representing an existing file)
Gray matter/pia mater surface meshes
area_pial: (a list of items which are a pathlike object or string
representing an existing file)
Mean area of triangles each vertex on the pial surface is associated
with
curv_pial: (a list of items which are a pathlike object or string
representing an existing file)
Curvature of pial surface
smoothwm: (a list of items which are a pathlike object or string
representing an existing file)
Smoothed original surface meshes
sphere: (a list of items which are a pathlike object or string
representing an existing file)
Spherical surface meshes
sulc: (a list of items which are a pathlike object or string
representing an existing file)
Surface maps of sulcal depth
thickness: (a list of items which are a pathlike object or string
representing an existing file)
Surface maps of cortical thickness
volume: (a list of items which are a pathlike object or string
representing an existing file)
Surface maps of cortical volume
white: (a list of items which are a pathlike object or string
representing an existing file)
White/gray matter surface meshes
jacobian_white: (a list of items which are a pathlike object or
string representing an existing file)
Distortion required to register to spherical atlas
graymid: (a list of items which are a pathlike object or string
representing an existing file)
Graymid/midthickness surface meshes
label: (a list of items which are a pathlike object or string
representing an existing file)
Volume and surface label files
annot: (a list of items which are a pathlike object or string
representing an existing file)
Surface annotation files
aparc_aseg: (a list of items which are a pathlike object or string
representing an existing file)
Aparc parcellation projected into aseg volume
sphere_reg: (a list of items which are a pathlike object or string
representing an existing file)
Spherical registration file
aseg_stats: (a list of items which are a pathlike object or string
representing an existing file)
Automated segmentation statistics file
wmparc_stats: (a list of items which are a pathlike object or string
representing an existing file)
White matter parcellation statistics file
aparc_stats: (a list of items which are a pathlike object or string
representing an existing file)
Aparc parcellation statistics files
BA_stats: (a list of items which are a pathlike object or string
representing an existing file)
Brodmann Area statistics files
aparc_a2009s_stats: (a list of items which are a pathlike object or
string representing an existing file)
Aparc a2009s parcellation statistics files
curv_stats: (a list of items which are a pathlike object or string
representing an existing file)
Curvature statistics files
entorhinal_exvivo_stats: (a list of items which are a pathlike object
or string representing an existing file)
Entorhinal exvivo statistics files
Resample¶
Wraps the executable command mri_convert.
Use FreeSurfer mri_convert to up or down-sample image files
Examples¶
>>> from nipype.interfaces import freesurfer
>>> resampler = freesurfer.Resample()
>>> resampler.inputs.in_file = 'structural.nii'
>>> resampler.inputs.resampled_file = 'resampled.nii'
>>> resampler.inputs.voxel_size = (2.1, 2.1, 2.1)
>>> resampler.cmdline
'mri_convert -vs 2.10 2.10 2.10 -i structural.nii -o resampled.nii'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
file to resample
argument: ``-i %s``, position: -2
voxel_size: (a tuple of the form: (a float, a float, a float))
triplet of output voxel sizes
argument: ``-vs %.2f %.2f %.2f``
[Optional]
resampled_file: (a pathlike object or string representing a file)
output filename
argument: ``-o %s``, position: -1
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
resampled_file: (a pathlike object or string representing an existing
file)
output filename
RobustRegister¶
Wraps the executable command mri_robust_register.
Perform intramodal linear registration (translation and rotation) using robust statistics.
Examples¶
>>> from nipype.interfaces.freesurfer import RobustRegister
>>> reg = RobustRegister()
>>> reg.inputs.source_file = 'structural.nii'
>>> reg.inputs.target_file = 'T1.nii'
>>> reg.inputs.auto_sens = True
>>> reg.inputs.init_orient = True
>>> reg.cmdline # doctest: +ELLIPSIS
'mri_robust_register --satit --initorient --lta .../structural_robustreg.lta --mov structural.nii --dst T1.nii'
References¶
- Reuter, M, Rosas, HD, and Fischl, B, (2010). Highly Accurate Inverse
- Consistent Registration: A Robust Approach. Neuroimage 53(4) 1181-96.
Inputs:
[Mandatory]
source_file: (a pathlike object or string representing an existing
file)
volume to be registered
argument: ``--mov %s``
target_file: (a pathlike object or string representing an existing
file)
target volume for the registration
argument: ``--dst %s``
auto_sens: (a boolean)
auto-detect good sensitivity
argument: ``--satit``
mutually_exclusive: outlier_sens
outlier_sens: (a float)
set outlier sensitivity explicitly
argument: ``--sat %.4f``
mutually_exclusive: auto_sens
[Optional]
out_reg_file: (a bool or None or a pathlike object or string
representing a file, nipype default value: True)
registration file; either True or filename
argument: ``--lta %s``
registered_file: (a boolean or a pathlike object or string
representing a file)
registered image; either True or filename
argument: ``--warp %s``
weights_file: (a boolean or a pathlike object or string representing
a file)
weights image to write; either True or filename
argument: ``--weights %s``
est_int_scale: (a boolean)
estimate intensity scale (recommended for unnormalized images)
argument: ``--iscale``
trans_only: (a boolean)
find 3 parameter translation only
argument: ``--transonly``
in_xfm_file: (a pathlike object or string representing an existing
file)
use initial transform on source
argument: ``--transform``
half_source: (a boolean or a pathlike object or string representing a
file)
write source volume mapped to halfway space
argument: ``--halfmov %s``
half_targ: (a boolean or a pathlike object or string representing a
file)
write target volume mapped to halfway space
argument: ``--halfdst %s``
half_weights: (a boolean or a pathlike object or string representing
a file)
write weights volume mapped to halfway space
argument: ``--halfweights %s``
half_source_xfm: (a boolean or a pathlike object or string
representing a file)
write transform from source to halfway space
argument: ``--halfmovlta %s``
half_targ_xfm: (a boolean or a pathlike object or string representing
a file)
write transform from target to halfway space
argument: ``--halfdstlta %s``
least_squares: (a boolean)
use least squares instead of robust estimator
argument: ``--leastsquares``
no_init: (a boolean)
skip transform init
argument: ``--noinit``
init_orient: (a boolean)
use moments for initial orient (recommended for stripped brains)
argument: ``--initorient``
max_iterations: (an integer (int or long))
maximum # of times on each resolution
argument: ``--maxit %d``
high_iterations: (an integer (int or long))
max # of times on highest resolution
argument: ``--highit %d``
iteration_thresh: (a float)
stop iterations when below threshold
argument: ``--epsit %.3f``
subsample_thresh: (an integer (int or long))
subsample if dimension is above threshold size
argument: ``--subsample %d``
outlier_limit: (a float)
set maximal outlier limit in satit
argument: ``--wlimit %.3f``
write_vo2vox: (a boolean)
output vox2vox matrix (default is RAS2RAS)
argument: ``--vox2vox``
no_multi: (a boolean)
work on highest resolution
argument: ``--nomulti``
mask_source: (a pathlike object or string representing an existing
file)
image to mask source volume with
argument: ``--maskmov %s``
mask_target: (a pathlike object or string representing an existing
file)
image to mask target volume with
argument: ``--maskdst %s``
force_double: (a boolean)
use double-precision intensities
argument: ``--doubleprec``
force_float: (a boolean)
use float intensities
argument: ``--floattype``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_reg_file: (a pathlike object or string representing an existing
file)
output registration file
registered_file: (a pathlike object or string representing an
existing file)
output image with registration applied
weights_file: (a pathlike object or string representing an existing
file)
image of weights used
half_source: (a pathlike object or string representing an existing
file)
source image mapped to halfway space
half_targ: (a pathlike object or string representing an existing
file)
target image mapped to halfway space
half_weights: (a pathlike object or string representing an existing
file)
weights image mapped to halfway space
half_source_xfm: (a pathlike object or string representing an
existing file)
transform file to map source image to halfway space
half_targ_xfm: (a pathlike object or string representing an existing
file)
transform file to map target image to halfway space
SegmentCC¶
Wraps the executable command mri_cc.
This program segments the corpus callosum into five separate labels in the subcortical segmentation volume ‘aseg.mgz’. The divisions of the cc are equally spaced in terms of distance along the primary eigendirection (pretty much the long axis) of the cc. The lateral extent can be changed with the -T <thickness> parameter, where <thickness> is the distance off the midline (so -T 1 would result in the who CC being 3mm thick). The default is 2 so it’s 5mm thick. The aseg.stats values should be volume.
Examples¶
>>> from nipype.interfaces import freesurfer
>>> SegmentCC_node = freesurfer.SegmentCC()
>>> SegmentCC_node.inputs.in_file = "aseg.mgz"
>>> SegmentCC_node.inputs.in_norm = "norm.mgz"
>>> SegmentCC_node.inputs.out_rotation = "cc.lta"
>>> SegmentCC_node.inputs.subject_id = "test"
>>> SegmentCC_node.cmdline
'mri_cc -aseg aseg.mgz -o aseg.auto.mgz -lta cc.lta test'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
Input aseg file to read from subjects directory
argument: ``-aseg %s``
in_norm: (a pathlike object or string representing an existing file)
Required undocumented input {subject}/mri/norm.mgz
out_rotation: (a pathlike object or string representing a file)
Global filepath for writing rotation lta
argument: ``-lta %s``
subject_id: (a string, nipype default value: subject_id)
Subject name
argument: ``%s``, position: -1
[Optional]
out_file: (a pathlike object or string representing a file)
Filename to write aseg including CC
argument: ``-o %s``
copy_inputs: (a boolean)
If running as a node, set this to True.This will copy the input
files to the node directory.
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
Output segmentation uncluding corpus collosum
out_rotation: (a pathlike object or string representing a file)
Output lta rotation file
SegmentWM¶
Wraps the executable command mri_segment.
This program segments white matter from the input volume. The input volume should be normalized such that white matter voxels are ~110-valued, and the volume is conformed to 256^3.
Examples¶
>>> from nipype.interfaces import freesurfer
>>> SegmentWM_node = freesurfer.SegmentWM()
>>> SegmentWM_node.inputs.in_file = "norm.mgz"
>>> SegmentWM_node.inputs.out_file = "wm.seg.mgz"
>>> SegmentWM_node.cmdline
'mri_segment norm.mgz wm.seg.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
Input file for SegmentWM
argument: ``%s``, position: -2
out_file: (a pathlike object or string representing a file)
File to be written as output for SegmentWM
argument: ``%s``, position: -1
[Optional]
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
Output white matter segmentation
Smooth¶
Wraps the executable command mris_volsmooth.
Use FreeSurfer mris_volsmooth to smooth a volume
This function smoothes cortical regions on a surface and non-cortical regions in volume.
Note
Cortical voxels are mapped to the surface (3D->2D) and then the smoothed values from the surface are put back into the volume to fill the cortical ribbon. If data is smoothed with this algorithm, one has to be careful about how further processing is interpreted.
Examples¶
>>> from nipype.interfaces.freesurfer import Smooth
>>> smoothvol = Smooth(in_file='functional.nii', smoothed_file = 'foo_out.nii', reg_file='register.dat', surface_fwhm=10, vol_fwhm=6)
>>> smoothvol.cmdline
'mris_volsmooth --i functional.nii --reg register.dat --o foo_out.nii --fwhm 10.000000 --vol-fwhm 6.000000'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
source volume
argument: ``--i %s``
reg_file: (a pathlike object or string representing an existing file)
registers volume to surface anatomical
argument: ``--reg %s``
surface_fwhm: (a floating point number >= 0.0)
surface FWHM in mm
argument: ``--fwhm %f``
mutually_exclusive: num_iters
requires: reg_file
num_iters: (a long integer >= 1)
number of iterations instead of fwhm
argument: ``--niters %d``
mutually_exclusive: surface_fwhm
[Optional]
smoothed_file: (a pathlike object or string representing a file)
output volume
argument: ``--o %s``
proj_frac_avg: (a tuple of the form: (a float, a float, a float))
average a long normal min max delta
argument: ``--projfrac-avg %.2f %.2f %.2f``
mutually_exclusive: proj_frac
proj_frac: (a float)
project frac of thickness a long surface normal
argument: ``--projfrac %s``
mutually_exclusive: proj_frac_avg
vol_fwhm: (a floating point number >= 0.0)
volume smoothing outside of surface
argument: ``--vol-fwhm %f``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
smoothed_file: (a pathlike object or string representing an existing
file)
smoothed input volume
SynthesizeFLASH¶
Wraps the executable command mri_synthesize.
Synthesize a FLASH acquisition from T1 and proton density maps.
Examples¶
>>> from nipype.interfaces.freesurfer import SynthesizeFLASH
>>> syn = SynthesizeFLASH(tr=20, te=3, flip_angle=30)
>>> syn.inputs.t1_image = 'T1.mgz'
>>> syn.inputs.pd_image = 'PD.mgz'
>>> syn.inputs.out_file = 'flash_30syn.mgz'
>>> syn.cmdline
'mri_synthesize 20.00 30.00 3.000 T1.mgz PD.mgz flash_30syn.mgz'
Inputs:
[Mandatory]
tr: (a float)
repetition time (in msec)
argument: ``%.2f``, position: 2
flip_angle: (a float)
flip angle (in degrees)
argument: ``%.2f``, position: 3
te: (a float)
echo time (in msec)
argument: ``%.3f``, position: 4
t1_image: (a pathlike object or string representing an existing file)
image of T1 values
argument: ``%s``, position: 5
pd_image: (a pathlike object or string representing an existing file)
image of proton density values
argument: ``%s``, position: 6
[Optional]
fixed_weighting: (a boolean)
use a fixed weighting to generate optimal gray/white contrast
argument: ``-w``, position: 1
out_file: (a pathlike object or string representing a file)
image to write
argument: ``%s``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing an existing file)
synthesized FLASH acquisition
UnpackSDICOMDir¶
Wraps the executable command unpacksdcmdir.
Use unpacksdcmdir to convert dicom files
Call unpacksdcmdir -help from the command line to see more information on using this command.
Examples¶
>>> from nipype.interfaces.freesurfer import UnpackSDICOMDir
>>> unpack = UnpackSDICOMDir()
>>> unpack.inputs.source_dir = '.'
>>> unpack.inputs.output_dir = '.'
>>> unpack.inputs.run_info = (5, 'mprage', 'nii', 'struct')
>>> unpack.inputs.dir_structure = 'generic'
>>> unpack.cmdline
'unpacksdcmdir -generic -targ . -run 5 mprage nii struct -src .'
Inputs:
[Mandatory]
source_dir: (a pathlike object or string representing an existing
directory)
directory with the DICOM files
argument: ``-src %s``
run_info: (a tuple of the form: (an integer (int or long), a unicode
string, a unicode string, a unicode string))
runno subdir format name : spec unpacking rules on cmdline
argument: ``-run %d %s %s %s``
mutually_exclusive: run_info, config, seq_config
config: (a pathlike object or string representing an existing file)
specify unpacking rules in file
argument: ``-cfg %s``
mutually_exclusive: run_info, config, seq_config
seq_config: (a pathlike object or string representing an existing
file)
specify unpacking rules based on sequence
argument: ``-seqcfg %s``
mutually_exclusive: run_info, config, seq_config
[Optional]
output_dir: (a pathlike object or string representing a directory)
top directory into which the files will be unpacked
argument: ``-targ %s``
dir_structure: ('fsfast' or 'generic')
unpack to specified directory structures
argument: ``-%s``
no_info_dump: (a boolean)
do not create infodump file
argument: ``-noinfodump``
scan_only: (a pathlike object or string representing an existing
file)
only scan the directory and put result in file
argument: ``-scanonly %s``
log_file: (a pathlike object or string representing an existing file)
explicilty set log file
argument: ``-log %s``
spm_zeropad: (an integer (int or long))
set frame number zero padding width for SPM
argument: ``-nspmzeropad %d``
no_unpack_err: (a boolean)
do not try to unpack runs with errors
argument: ``-no-unpackerr``
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
None
WatershedSkullStrip¶
Wraps the executable command mri_watershed.
This program strips skull and other outer non-brain tissue and produces the brain volume from T1 volume or the scanned volume.
The “watershed” segmentation algorithm was used to dertermine the intensity values for white matter, grey matter, and CSF. A force field was then used to fit a spherical surface to the brain. The shape of the surface fit was then evaluated against a previously derived template.
The default parameters are: -w 0.82 -b 0.32 -h 10 -seedpt -ta -wta
(Segonne 2004)
Examples¶
>>> from nipype.interfaces.freesurfer import WatershedSkullStrip
>>> skullstrip = WatershedSkullStrip()
>>> skullstrip.inputs.in_file = "T1.mgz"
>>> skullstrip.inputs.t1 = True
>>> skullstrip.inputs.transform = "transforms/talairach_with_skull.lta"
>>> skullstrip.inputs.out_file = "brainmask.auto.mgz"
>>> skullstrip.cmdline
'mri_watershed -T1 transforms/talairach_with_skull.lta T1.mgz brainmask.auto.mgz'
Inputs:
[Mandatory]
in_file: (a pathlike object or string representing an existing file)
input volume
argument: ``%s``, position: -2
out_file: (a pathlike object or string representing a file, nipype
default value: brainmask.auto.mgz)
output volume
argument: ``%s``, position: -1
[Optional]
t1: (a boolean)
specify T1 input volume (T1 grey value = 110)
argument: ``-T1``
brain_atlas: (a pathlike object or string representing an existing
file)
argument: ``-brain_atlas %s``, position: -4
transform: (a pathlike object or string representing a file)
undocumented
argument: ``%s``, position: -3
subjects_dir: (a pathlike object or string representing an existing
directory)
subjects directory
args: (a unicode string)
Additional parameters to the command
argument: ``%s``
environ: (a dictionary with keys which are a bytes or None or a value
of class 'str' and with values which are a bytes or None or a
value of class 'str', nipype default value: {})
Environment variables
Outputs:
out_file: (a pathlike object or string representing a file)
skull stripped brain volume