class FieldToRadSOutputSpec(TraitedSpec):
out_file = File(desc='the output fieldmap')
fmap_range = traits.Float(desc='range of input field map')
class SubjectInfoInputSpec(BaseInterfaceInputSpec):
conditions = traits.List(traits.Str(exists=True))
durations = traits.List(traits.List(traits.Float(exists=True)))
measurement_delay = traits.Float(exists=True, mandatory=True)
onsets = traits.List(traits.List(traits.Float(exists=True)))
class BandpassInputSpec(AFNICommandInputSpec):
in_file = File(desc='input file to 3dBandpass',
argstr='%s',
position=-1,
mandatory=True,
exists=True,
copyfile=False)
out_file = File(name_template='%s_bp',
desc='output file from 3dBandpass',
argstr='-prefix %s',
position=1,
name_source='in_file',
genfile=True)
lowpass = traits.Float(desc='lowpass',
argstr='%f',
position=-2,
mandatory=True)
highpass = traits.Float(desc='highpass',
argstr='%f',
position=-3,
mandatory=True)
mask = File(desc='mask file', position=2, argstr='-mask %s', exists=True)
despike = traits.Bool(
argstr='-despike',
desc="""Despike each time series before other processing.
++ Hopefully, you don't actually need to do this,
which is why it is optional.""")
orthogonalize_file = InputMultiPath(
File(exists=True),
argstr="-ort %s",
desc="""Also orthogonalize input to columns in f.1D
++ Multiple '-ort' options are allowed.""")
orthogonalize_dset = File(
exists=True,
argstr="-dsort %s",
desc="""Orthogonalize each voxel to the corresponding
voxel time series in dataset 'fset', which must
have the same spatial and temporal grid structure
as the main input dataset.
++ At present, only one '-dsort' option is allowed.""")
no_detrend = traits.Bool(
argstr='-nodetrend',
desc="""Skip the quadratic detrending of the input that
occurs before the FFT-based bandpassing.
++ You would only want to do this if the dataset
had been detrended already in some other program.""")
tr = traits.Float(
argstr="-dt %f",
desc="set time step (TR) in sec [default=from dataset header]")
nfft = traits.Int(argstr='-nfft %d',
desc="set the FFT length [must be a legal value]")
normalize = traits.Bool(
argstr='-norm',
desc="""Make all output time series have L2 norm = 1
++ i.e., sum of squares = 1""")
automask = traits.Bool(argstr='-automask',
desc="Create a mask from the input dataset")
blur = traits.Float(argstr='-blur %f',
desc="""Blur (inside the mask only) with a filter
width (FWHM) of 'fff' millimeters.""")
localPV = traits.Float(
argstr='-localPV %f',
desc="""Replace each vector by the local Principal Vector
(AKA first singular vector) from a neighborhood
of radius 'rrr' millimiters.
++ Note that the PV time series is L2 normalized.
++ This option is mostly for Bob Cox to have fun with.""")
notrans = traits.Bool(
argstr='-notrans',
desc="""Don't check for initial positive transients in the data:
++ The test is a little slow, so skipping it is OK,
if you KNOW the data time series are transient-free.""")
class GenerateTestImageInputSpec(CommandLineInputSpec):
inputVolume = File(desc="input volume 1, usally t1 image", exists=True, argstr="--inputVolume %s")
outputVolume = traits.Either(traits.Bool, File(), hash_files=False, desc="(required) output file name", argstr="--outputVolume %s")
lowerBoundOfOutputVolume = traits.Float(argstr="--lowerBoundOfOutputVolume %f")
upperBoundOfOutputVolume = traits.Float(argstr="--upperBoundOfOutputVolume %f")
outputVolumeSize = traits.Float(desc="output Volume Size", argstr="--outputVolumeSize %f")
class DilateMaskInputSpec(CommandLineInputSpec):
inputVolume = File(desc="Required: input image", exists=True, argstr="--inputVolume %s")
inputBinaryVolume = File(desc="Required: input brain mask image", exists=True, argstr="--inputBinaryVolume %s")
sizeStructuralElement = traits.Int(desc="size of structural element. sizeStructuralElement=1 means that 3x3x3 structuring element for 3D", argstr="--sizeStructuralElement %d")
lowerThreshold = traits.Float(desc="Required: lowerThreshold value", argstr="--lowerThreshold %f")
outputVolume = traits.Either(traits.Bool, File(), hash_files=False, desc="Required: output image", argstr="--outputVolume %s")
class _AntsJointFusionInputSpec(ANTSCommandInputSpec):
dimension = traits.Enum(3,
2,
4,
argstr='-d %d',
desc='This option forces the image to be treated '
'as a specified-dimensional image. If not '
'specified, the program tries to infer the '
'dimensionality from the input image.')
target_image = traits.List(base.InputMultiPath(base.File(exists=True)),
argstr='-t %s',
mandatory=True,
desc='The target image (or '
'multimodal target images) assumed to be '
'aligned to a common image domain.')
atlas_image = traits.List(base.InputMultiPath(base.File(exists=True)),
argstr="-g %s...",
mandatory=True,
desc='The atlas image (or '
'multimodal atlas images) assumed to be '
'aligned to a common image domain.')
atlas_segmentation_image = base.InputMultiPath(
base.File(exists=True),
argstr="-l %s...",
mandatory=True,
desc='The atlas segmentation '
'images. For performing label fusion the number '
'of specified segmentations should be identical '
'to the number of atlas image sets.')
alpha = traits.Float(
default_value=0.1,
usedefault=True,
argstr='-a %s',
desc=(
'Regularization '
'term added to matrix Mx for calculating the inverse. Default = 0.1'
))
beta = traits.Float(
default_value=2.0,
usedefault=True,
argstr='-b %s',
desc=('Exponent for mapping '
'intensity difference to the joint error. Default = 2.0'))
retain_label_posterior_images = traits.Bool(
False,
argstr='-r',
usedefault=True,
requires=['atlas_segmentation_image'],
desc=('Retain label posterior probability images. Requires '
'atlas segmentations to be specified. Default = false'))
retain_atlas_voting_images = traits.Bool(
False,
argstr='-f',
usedefault=True,
desc=('Retain atlas voting images. Default = false'))
constrain_nonnegative = traits.Bool(
False,
argstr='-c',
usedefault=True,
desc=('Constrain solution to non-negative weights.'))
patch_radius = traits.ListInt(minlen=3,
maxlen=3,
argstr='-p %s',
desc=('Patch radius for similarity measures.'
'Default: 2x2x2'))
patch_metric = traits.Enum(
'PC',
'MSQ',
argstr='-m %s',
desc=('Metric to be used in determining the most similar '
'neighborhood patch. Options include Pearson\'s '
'correlation (PC) and mean squares (MSQ). Default = '
'PC (Pearson correlation).'))
search_radius = traits.List(
[3, 3, 3],
minlen=1,
maxlen=3,
argstr='-s %s',
usedefault=True,
desc=('Search radius for similarity measures. Default = 3x3x3. '
'One can also specify an image where the value at the '
'voxel specifies the isotropic search radius at that voxel.'))
exclusion_image_label = traits.List(
traits.Str(),
argstr='-e %s',
requires=['exclusion_image'],
desc=('Specify a label for the exclusion region.'))
exclusion_image = traits.List(
base.File(exists=True),
desc=('Specify an exclusion region for the given label.'))
mask_image = base.File(
argstr='-x %s',
exists=True,
desc='If a mask image '
'is specified, fusion is only performed in the mask region.')
out_label_fusion = base.File(argstr="%s",
hash_files=False,
desc='The output label fusion image.')
out_intensity_fusion_name_format = traits.Str(
argstr="",
desc='Optional intensity fusion '
'image file name format. '
'(e.g. "antsJointFusionIntensity_%d.nii.gz")')
out_label_post_prob_name_format = traits.Str(
'antsJointFusionPosterior_%d.nii.gz',
requires=['out_label_fusion', 'out_intensity_fusion_name_format'],
desc='Optional label posterior probability '
'image file name format.')
out_atlas_voting_weight_name_format = traits.Str(
'antsJointFusionVotingWeight_%d.nii.gz',
requires=[
'out_label_fusion', 'out_intensity_fusion_name_format',
'out_label_post_prob_name_format'
],
desc='Optional atlas voting weight image '
'file name format.')
verbose = traits.Bool(False, argstr="-v", desc=('Verbose output.'))
class _BinarizeInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc="input image")
thresh_low = traits.Float(mandatory=True,
desc="non-inclusive lower threshold")
class DWIConvertInputSpec(CommandLineInputSpec):
conversionMode = traits.Enum(
"DicomToNrrd",
"DicomToFSL",
"NrrdToFSL",
"FSLToNrrd",
desc=
"Determine which conversion to perform. DicomToNrrd (default): Convert DICOM series to NRRD DicomToFSL: Convert DICOM series to NIfTI File + gradient/bvalue text files NrrdToFSL: Convert DWI NRRD file to NIfTI File + gradient/bvalue text files FSLToNrrd: Convert NIfTI File + gradient/bvalue text files to NRRD file.",
argstr="--conversionMode %s")
inputVolume = File(
desc="Input DWI volume -- not used for DicomToNrrd mode.",
exists=True,
argstr="--inputVolume %s")
outputVolume = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="Output filename (.nhdr or .nrrd)",
argstr="--outputVolume %s")
fMRI = traits.Bool(desc="Output a NRRD file, but without gradients",
argstr="--fMRI ")
inputDicomDirectory = Directory(desc="Directory holding Dicom series",
exists=True,
argstr="--inputDicomDirectory %s")
outputDirectory = traits.Either(
traits.Bool,
Directory(),
hash_files=False,
desc="Directory holding the output NRRD file",
argstr="--outputDirectory %s")
gradientVectorFile = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc="Text file giving gradient vectors",
argstr="--gradientVectorFile %s")
smallGradientThreshold = traits.Float(
desc=
"If a gradient magnitude is greater than 0 and less than smallGradientThreshold, then DWIConvert will display an error message and quit, unless the useBMatrixGradientDirections option is set.",
argstr="--smallGradientThreshold %f")
writeProtocolGradientsFile = traits.Bool(
desc=
"Write the protocol gradients to a file suffixed by \'.txt\' as they were specified in the procol by multiplying each diffusion gradient direction by the measurement frame. This file is for debugging purposes only, the format is not fixed, and will likely change as debugging of new dicom formats is necessary.",
argstr="--writeProtocolGradientsFile ")
useIdentityMeaseurementFrame = traits.Bool(
desc=
"Adjust all the gradients so that the measurement frame is an identity matrix.",
argstr="--useIdentityMeaseurementFrame ")
useBMatrixGradientDirections = traits.Bool(
desc=
"Fill the nhdr header with the gradient directions and bvalues computed out of the BMatrix. Only changes behavior for Siemens data. In some cases the standard public gradients are not properly computed. The gradients can emperically computed from the private BMatrix fields. In some cases the private BMatrix is consistent with the public grandients, but not in all cases, when it exists BMatrix is usually most robust.",
argstr="--useBMatrixGradientDirections ")
inputBValues = File(desc="B Values text file",
exists=True,
argstr="--inputBValues %s")
inputBVectors = File(desc="B Vector text file",
exists=True,
argstr="--inputBVectors %s")
outputBValues = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="B Values text file",
argstr="--outputBValues %s")
outputBVectors = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="B Vector text file",
argstr="--outputBVectors %s")
class ProbTrackXInputSpec(FSLCommandInputSpec):
thsamples = InputMultiPath(File(exists=True), mandatory=True)
phsamples = InputMultiPath(File(exists=True), mandatory=True)
fsamples = InputMultiPath(File(exists=True), mandatory=True)
samples_base_name = traits.Str(
"merged",
desc='the rootname/base_name for samples files',
argstr='--samples=%s',
usedefault=True)
mask = File(exists=True,
desc='bet binary mask file in diffusion space',
argstr='-m %s',
mandatory=True)
seed = traits.Either(
File(exists=True),
traits.List(File(exists=True)),
traits.List(traits.List(traits.Int(), minlen=3, maxlen=3)),
desc='seed volume(s), or voxel(s)' + 'or freesurfer label file',
argstr='--seed=%s',
mandatory=True)
mode = traits.Enum(
"simple",
"two_mask_symm",
"seedmask",
desc=
'options: simple (single seed voxel), seedmask (mask of seed voxels), '
+ 'twomask_symm (two bet binary masks) ',
argstr='--mode=%s',
genfile=True)
target_masks = InputMultiPath(
File(exits=True),
desc='list of target masks - ' +
'required for seeds_to_targets classification',
argstr='--targetmasks=%s')
mask2 = File(
exists=True,
desc='second bet binary mask (in diffusion space) in twomask_symm mode',
argstr='--mask2=%s')
waypoints = File(exists=True,
desc='waypoint mask or ascii list of waypoint masks - ' +
'only keep paths going through ALL the masks',
argstr='--waypoints=%s')
network = traits.Bool(
desc='activate network mode - only keep paths going through ' +
'at least one seed mask (required if multiple seed masks)',
argstr='--network')
mesh = File(exists=True,
desc='Freesurfer-type surface descriptor (in ascii format)',
argstr='--mesh=%s')
seed_ref = File(exists=True,
desc='reference vol to define seed space in ' +
'simple mode - diffusion space assumed if absent',
argstr='--seedref=%s')
out_dir = Directory(exists=True,
argstr='--dir=%s',
desc='directory to put the final volumes in',
genfile=True)
force_dir = traits.Bool(
True,
desc='use the actual directory name given - i.e. ' +
'do not add + to make a new directory',
argstr='--forcedir',
usedefault=True)
opd = traits.Bool(True,
desc='outputs path distributions',
argstr='--opd',
usedefault=True)
correct_path_distribution = traits.Bool(
desc='correct path distribution for the length of the pathways',
argstr='--pd')
os2t = traits.Bool(desc='Outputs seeds to targets', argstr='--os2t')
#paths_file = File('nipype_fdtpaths', usedefault=True, argstr='--out=%s',
# desc='produces an output file (default is fdt_paths)')
avoid_mp = File(
exists=True,
desc='reject pathways passing through locations given by this mask',
argstr='--avoid=%s')
stop_mask = File(exists=True,
argstr='--stop=%s',
desc='stop tracking at locations given by this mask file')
xfm = File(
exists=True,
argstr='--xfm=%s',
desc='transformation matrix taking seed space to DTI space ' +
'(either FLIRT matrix or FNIRT warp_field) - default is identity')
inv_xfm = File(
argstr='--invxfm=%s',
desc='transformation matrix taking DTI space to seed' +
' space (compulsory when using a warp_field for seeds_to_dti)')
n_samples = traits.Int(5000,
argstr='--nsamples=%d',
desc='number of samples - default=5000',
usedefault=True)
n_steps = traits.Int(argstr='--nsteps=%d',
desc='number of steps per sample - default=2000')
dist_thresh = traits.Float(argstr='--distthresh=%.3f',
desc='discards samples shorter than ' +
'this threshold (in mm - default=0)')
c_thresh = traits.Float(argstr='--cthr=%.3f',
desc='curvature threshold - default=0.2')
sample_random_points = traits.Bool(
argstr='--sampvox', desc='sample random points within seed voxels')
step_length = traits.Float(argstr='--steplength=%.3f',
desc='step_length in mm - default=0.5')
loop_check = traits.Bool(argstr='--loopcheck',
desc='perform loop_checks on paths -' +
' slower, but allows lower curvature threshold')
use_anisotropy = traits.Bool(argstr='--usef',
desc='use anisotropy to constrain tracking')
rand_fib = traits.Enum(
0,
1,
2,
3,
argstr='--randfib=%d',
desc='options: 0 - default, 1 - to randomly sample' +
' initial fibres (with f > fibthresh), 2 - to sample in ' +
'proportion fibres (with f>fibthresh) to f, 3 - to sample ALL ' +
'populations at random (even if f<fibthresh)')
fibst = traits.Int(
argstr='--fibst=%d',
desc='force a starting fibre for tracking - ' +
'default=1, i.e. first fibre orientation. Only works if randfib==0')
mod_euler = traits.Bool(argstr='--modeuler',
desc='use modified euler streamlining')
random_seed = traits.Bool(argstr='--rseed', desc='random seed')
s2tastext = traits.Bool(argstr='--s2tastext',
desc='output seed-to-target counts as a' +
' text file (useful when seeding from a mesh)')
verbose = traits.Enum(0,
1,
2,
desc="Verbose level, [0-2]." +
"Level 2 is required to output particle files.",
argstr="--verbose=%d")
class SimpleThresholdInputSpec(BaseInterfaceInputSpec):
volume = File(exists=True, desc='volume to be thresholded', mandatory=True)
threshold = traits.Float(
desc='everything below this value will be set to zero', mandatory=True)
class MultivariateTemplateConstruction2InputSpec(CommandLineInputSpec):
dimension = traits.Enum(2,
3,
4,
default=3,
usedefault=True,
argstr='-d %d')
input_file = File(desc="txt or csv file with images",
exists=True,
position=-1)
input_images = InputMultiObject(traits.Either(
File(exists=True), InputMultiObject(File(exists=True))),
desc='list of images or lists of images',
xor=('input_file', ),
argstr='%s',
position=-1,
copyfile=False)
image_statistic = traits.Enum(
0,
1,
2,
default=1,
usedefault=True,
desc='statistic used to summarize '
'images. 0=mean, 1= mean of normalized intensities, 2=median')
iteration_limit = traits.Int(4,
usedefault=True,
argstr='-i %d',
desc='maximum number of iterations')
backup_images = traits.Bool(False, argstr='-b %d')
parallel_control = traits.Enum(0,
1,
2,
3,
4,
5,
desc='Control for parallel computation '
'0 = run serially, '
'1 = SGE qsub, '
'2 = use PEXEC (localhost), '
'3 = Apple XGrid, '
'4 = PBS qsub, '
'5 = SLURM',
argstr='-c %d',
usedefault=True,
hash_files=False)
num_cores = traits.Int(default=1,
usedefault=True,
argstr='-j %d',
hash_files=False)
num_modalities = traits.Int(
1,
usedefault=True,
desc='Number of modalities used '
'to construct the template (default 1): For example, '
'if one wanted to create a multimodal template consisting of T1,T2,and FA '
'components ("-k 3")',
argstr='-k %d')
modality_weights = traits.List([1], usedefault=True)
n4_bias_correct = traits.Bool(True, usedefault=True, argstr='-n %d')
metric = traits.Str('CC', usedefault=True, argstr='-m %s', mandatory=True)
transform = traits.Enum('BSplineSyN',
'SyN',
'Affine',
usedefault=True,
argstr='-t %s',
mandatory=True)
output_prefix = traits.Str('antsBTP')
gradient_step = traits.Float(0.25,
usedefault=True,
mandatory=True,
argstr='-g %.3f')
usefloat = traits.Bool(True, argstr='-e %d', usedefault=True)
class ODFTrackerInputSpec(CommandLineInputSpec):
max = File(exists=True, mandatory=True)
ODF = File(exists=True, mandatory=True)
input_data_prefix = traits.Str("odf",
desc='recon data prefix',
argstr='%s',
usedefault=True,
position=0)
out_file = File("tracks.trk",
desc='output track file',
argstr='%s',
usedefault=True,
position=1)
input_output_type = traits.Enum('nii',
'analyze',
'ni1',
'nii.gz',
argstr='-it %s',
desc='input and output file type',
usedefault=True)
runge_kutta2 = traits.Bool(
argstr='-rk2',
desc="""use 2nd order runge-kutta method for tracking.
default tracking method is non-interpolate streamline""")
step_length = traits.Float(
argstr='-l %f',
desc="""set step length, in the unit of minimum voxel size.
default value is 0.1.""")
angle_threshold = traits.Float(
argstr='-at %f',
desc="""set angle threshold. default value is 35 degree for
default tracking method and 25 for rk2""")
random_seed = traits.Int(
argstr='-rseed %s',
desc="""use random location in a voxel instead of the center of the voxel
to seed. can also define number of seed per voxel. default is 1""")
invert_x = traits.Bool(argstr='-ix',
desc='invert x component of the vector')
invert_y = traits.Bool(argstr='-iy',
desc='invert y component of the vector')
invert_z = traits.Bool(argstr='-iz',
desc='invert z component of the vector')
swap_xy = traits.Bool(argstr='-sxy',
desc='swap x and y vectors while tracking')
swap_yz = traits.Bool(argstr='-syz',
desc='swap y and z vectors while tracking')
swap_zx = traits.Bool(argstr='-szx',
desc='swap x and z vectors while tracking')
disc = traits.Bool(argstr='-disc', desc='use disc tracking')
mask1_file = File(desc="first mask image",
mandatory=True,
argstr="-m %s",
position=2)
mask1_threshold = traits.Float(
desc=
"threshold value for the first mask image, if not given, the program will \
try automatically find the threshold",
position=3)
mask2_file = File(desc="second mask image", argstr="-m2 %s", position=4)
mask2_threshold = traits.Float(
desc=
"threshold value for the second mask image, if not given, the program will \
try automatically find the threshold",
position=5)
limit = traits.Int(
argstr='-limit %d',
desc="""in some special case, such as heart data, some track may go into
infinite circle and take long time to stop. this option allows
setting a limit for the longest tracking steps (voxels)""")
dsi = traits.Bool(
argstr='-dsi',
desc=""" specify the input odf data is dsi. because dsi recon uses fixed
pre-calculated matrix, some special orientation patch needs to
be applied to keep dti/dsi/q-ball consistent.""")
image_orientation_vectors = traits.List(
traits.Float(),
minlen=6,
maxlen=6,
desc="""specify image orientation vectors. if just one argument given,
will treat it as filename and read the orientation vectors from
the file. if 6 arguments are given, will treat them as 6 float
numbers and construct the 1st and 2nd vector and calculate the 3rd
one automatically.
this information will be used to determine image orientation,
as well as to adjust gradient vectors with oblique angle when""",
argstr="-iop %f")
slice_order = traits.Int(
argstr='-sorder %d',
desc=
'set the slice order. 1 means normal, -1 means reversed. default value is 1'
)
voxel_order = traits.Enum(
'RAS',
'RPS',
'RAI',
'RPI',
'LAI',
'LAS',
'LPS',
'LPI',
argstr='-vorder %s',
desc=
"""specify the voxel order in RL/AP/IS (human brain) reference. must be
3 letters with no space in between.
for example, RAS means the voxel row is from L->R, the column
is from P->A and the slice order is from I->S.
by default voxel order is determined by the image orientation
(but NOT guaranteed to be correct because of various standards).
for example, siemens axial image is LPS, coronal image is LIP and
sagittal image is PIL.
this information also is NOT needed for tracking but will be saved
in the track file and is essential for track display to map onto
the right coordinates""")
class ODFReconInputSpec(CommandLineInputSpec):
DWI = File(desc='Input raw data',
argstr='%s',
exists=True,
mandatory=True,
position=1)
n_directions = traits.Int(desc='Number of directions',
argstr='%s',
mandatory=True,
position=2)
n_output_directions = traits.Int(desc='Number of output directions',
argstr='%s',
mandatory=True,
position=3)
out_prefix = traits.Str("odf",
desc='Output file prefix',
argstr='%s',
usedefault=True,
position=4)
matrix = File(argstr='-mat %s',
exists=True,
desc="""use given file as reconstruction matrix.""",
mandatory=True)
n_b0 = traits.Int(
argstr='-b0 %s',
desc="""number of b0 scans. by default the program gets this information
from the number of directions and number of volumes in
the raw data. useful when dealing with incomplete raw
data set or only using part of raw data set to reconstruct""",
mandatory=True)
output_type = traits.Enum('nii',
'analyze',
'ni1',
'nii.gz',
argstr='-ot %s',
desc='output file type',
usedefault=True)
sharpness = traits.Float(
desc="""smooth or sharpen the raw data. factor > 0 is smoothing.
factor < 0 is sharpening. default value is 0
NOTE: this option applies to DSI study only""",
argstr='-s %f')
filter = traits.Bool(
desc="""apply a filter (e.g. high pass) to the raw image""",
argstr='-f')
subtract_background = traits.Bool(
desc="""subtract the background value before reconstruction""",
argstr='-bg')
dsi = traits.Bool(desc="""indicates that the data is dsi""", argstr='-dsi')
output_entropy = traits.Bool(desc="""output entropy map""", argstr='-oe')
image_orientation_vectors = traits.List(
traits.Float(),
minlen=6,
maxlen=6,
desc="""specify image orientation vectors. if just one argument given,
will treat it as filename and read the orientation vectors from
the file. if 6 arguments are given, will treat them as 6 float
numbers and construct the 1st and 2nd vector and calculate the 3rd
one automatically.
this information will be used to determine image orientation,
as well as to adjust gradient vectors with oblique angle when""",
argstr="-iop %f")
oblique_correction = traits.Bool(
desc="""when oblique angle(s) applied, some SIEMENS dti protocols do not
adjust gradient accordingly, thus it requires adjustment for correct
diffusion tensor calculation""",
argstr="-oc")
class FieldToHzInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc='input fieldmap')
range_hz = traits.Float(mandatory=True, desc='range of input field map')
class ResampleScalarVectorDWIVolumeInputSpec(CommandLineInputSpec):
inputVolume = File(position=-2,
desc="Input Volume to be resampled",
exists=True,
argstr="%s")
outputVolume = traits.Either(traits.Bool,
File(),
position=-1,
hash_files=False,
desc="Resampled Volume",
argstr="%s")
Reference = File(desc="Reference Volume (spacing,size,orientation,origin)",
exists=True,
argstr="--Reference %s")
transformationFile = File(exists=True, argstr="--transformationFile %s")
defField = File(
desc=
"File containing the deformation field (3D vector image containing vectors with 3 components)",
exists=True,
argstr="--defField %s")
hfieldtype = traits.Enum("displacement",
"h-Field",
desc="Set if the deformation field is an h-Field",
argstr="--hfieldtype %s")
interpolation = traits.Enum(
"linear",
"nn",
"ws",
"bs",
desc=
"Sampling algorithm (linear or nn (nearest neighborhoor), ws (WindowedSinc), bs (BSpline) )",
argstr="--interpolation %s")
transform_order = traits.Enum(
"input-to-output",
"output-to-input",
desc="Select in what order the transforms are read",
argstr="--transform_order %s")
notbulk = traits.Bool(
desc=
"The transform following the BSpline transform is not set as a bulk transform for the BSpline transform",
argstr="--notbulk ")
spaceChange = traits.Bool(
desc=
"Space Orientation between transform and image is different (RAS/LPS) (warning: if the transform is a Transform Node in Slicer3, do not select)",
argstr="--spaceChange ")
rotation_point = traits.List(
desc=
"Rotation Point in case of rotation around a point (otherwise useless)",
argstr="--rotation_point %s")
centered_transform = traits.Bool(
desc=
"Set the center of the transformation to the center of the input image",
argstr="--centered_transform ")
image_center = traits.Enum(
"input",
"output",
desc=
"Image to use to center the transform (used only if \'Centered Transform\' is selected)",
argstr="--image_center %s")
Inverse_ITK_Transformation = traits.Bool(
desc=
"Inverse the transformation before applying it from output image to input image",
argstr="--Inverse_ITK_Transformation ")
spacing = InputMultiPath(
traits.Float,
desc="Spacing along each dimension (0 means use input spacing)",
sep=",",
argstr="--spacing %s")
size = InputMultiPath(
traits.Float,
desc="Size along each dimension (0 means use input size)",
sep=",",
argstr="--size %s")
origin = traits.List(desc="Origin of the output Image",
argstr="--origin %s")
direction_matrix = InputMultiPath(
traits.Float,
desc=
"9 parameters of the direction matrix by rows (ijk to LPS if LPS transform, ijk to RAS if RAS transform)",
sep=",",
argstr="--direction_matrix %s")
number_of_thread = traits.Int(
desc="Number of thread used to compute the output image",
argstr="--number_of_thread %d")
default_pixel_value = traits.Float(
desc=
"Default pixel value for samples falling outside of the input region",
argstr="--default_pixel_value %f")
window_function = traits.Enum(
"h",
"c",
"w",
"l",
"b",
desc=
"Window Function , h = Hamming , c = Cosine , w = Welch , l = Lanczos , b = Blackman",
argstr="--window_function %s")
spline_order = traits.Int(desc="Spline Order", argstr="--spline_order %d")
transform_matrix = InputMultiPath(
traits.Float,
desc=
"12 parameters of the transform matrix by rows ( --last 3 being translation-- )",
sep=",",
argstr="--transform_matrix %s")
transform = traits.Enum(
"rt",
"a",
desc="Transform algorithm, rt = Rigid Transform, a = Affine Transform",
argstr="--transform %s")
class EddyInputSpec(CommandLineInputSpec):
in_file = File(exists=True,
mandatory=True,
argstr='--imain=%s',
desc=('File containing all the images to estimate '
'distortions for'))
in_mask = File(exists=True,
mandatory=True,
argstr='--mask=%s',
desc='Mask to indicate brain')
in_index = File(exists=True,
mandatory=True,
argstr='--index=%s',
desc=('File containing indices for all volumes in --imain '
'into --acqp and --topup'))
in_acqp = File(exists=True,
mandatory=True,
argstr='--acqp=%s',
desc='File containing acquisition parameters')
in_bvec = File(exists=True,
mandatory=True,
argstr='--bvecs=%s',
desc=('File containing the b-vectors for all volumes in '
'--imain'))
in_bval = File(exists=True,
mandatory=True,
argstr='--bvals=%s',
desc=('File containing the b-values for all volumes in '
'--imain'))
out_base = traits.Str('eddy_corrected',
argstr='--out=%s',
usedefault=True,
desc=('basename for output (warped) image'))
session = File(exists=True,
argstr='--session=%s',
desc=('File containing session indices for all volumes in '
'--imain'))
in_topup_fieldcoef = File(exists=True,
argstr="--topup=%s",
requires=['in_topup_movpar'],
desc=('topup file containing the field '
'coefficients'))
in_topup_movpar = File(exists=True,
requires=['in_topup_fieldcoef'],
desc='topup movpar.txt file')
flm = traits.Enum('linear',
'quadratic',
'cubic',
argstr='--flm=%s',
desc='First level EC model')
slm = traits.Enum('none',
'linear',
'quadratic',
argstr='--slm=%s',
desc='Second level EC model')
fep = traits.Bool(False,
argstr='--fep',
desc='Fill empty planes in x- or y-directions')
interp = traits.Enum('spline',
'trilinear',
argstr='--interp=%s',
desc='Interpolation model for estimation step')
nvoxhp = traits.Int(1000,
usedefault=True,
argstr='--nvoxhp=%s',
desc=('# of voxels used to estimate the '
'hyperparameters'))
fudge_factor = traits.Float(10.0,
usedefault=True,
argstr='--ff=%s',
desc=('Fudge factor for hyperparameter '
'error variance'))
dont_sep_offs_move = traits.Bool(False,
argstr='--dont_sep_offs_move',
desc=('Do NOT attempt to separate '
'field offset from subject '
'movement'))
dont_peas = traits.Bool(False,
argstr='--dont_peas',
desc="Do NOT perform a post-eddy alignment of "
"shells")
fwhm = traits.Float(desc=('FWHM for conditioning filter when estimating '
'the parameters'),
argstr='--fwhm=%s')
niter = traits.Int(5,
usedefault=True,
argstr='--niter=%s',
desc='Number of iterations')
method = traits.Enum('jac',
'lsr',
argstr='--resamp=%s',
desc=('Final resampling method (jacobian/least '
'squares)'))
repol = traits.Bool(False,
argstr='--repol',
desc='Detect and replace outlier slices')
num_threads = traits.Int(1,
usedefault=True,
nohash=True,
desc="Number of openmp threads to use")
is_shelled = traits.Bool(False,
argstr='--data_is_shelled',
desc="Override internal check to ensure that "
"date are acquired on a set of b-value "
"shells")
field = traits.Str(argstr='--field=%s',
desc="NonTOPUP fieldmap scaled in Hz - filename has "
"to be provided without an extension. TOPUP is "
"strongly recommended")
field_mat = File(exists=True,
argstr='--field_mat=%s',
desc="Matrix that specifies the relative locations of "
"the field specified by --field and first volume "
"in file --imain")
use_cuda = traits.Bool(False, desc="Run eddy using cuda gpu")
class _AIInputSpec(ANTSCommandInputSpec):
dimension = traits.Int(3,
usedefault=True,
argstr='-d %d',
desc='dimension of output image')
verbose = traits.Bool(False,
usedefault=True,
argstr='-v %d',
desc='enable verbosity')
fixed_image = traits.File(
exists=True,
mandatory=True,
desc='Image to which the moving_image should be transformed')
moving_image = traits.File(
exists=True,
mandatory=True,
desc='Image that will be transformed to fixed_image')
fixed_image_mask = traits.File(exists=True,
argstr='-x %s',
desc='fixed mage mask')
moving_image_mask = traits.File(exists=True,
requires=['fixed_image_mask'],
desc='moving mage mask')
metric_trait = (traits.Enum("Mattes", "GC", "MI"), traits.Int(32),
traits.Enum('Regular', 'Random', 'None'),
traits.Range(value=0.2, low=0.0, high=1.0))
metric = traits.Tuple(*metric_trait,
argstr='-m %s',
mandatory=True,
desc='the metric(s) to use.')
transform = traits.Tuple(traits.Enum('Affine', 'Rigid', 'Similarity'),
traits.Range(value=0.1, low=0.0,
exclude_low=True),
argstr='-t %s[%f]',
usedefault=True,
desc='Several transform options are available')
principal_axes = traits.Bool(False,
usedefault=True,
argstr='-p %d',
xor=['blobs'],
desc='align using principal axes')
search_factor = traits.Tuple(traits.Float(20),
traits.Range(value=0.12, low=0.0, high=1.0),
usedefault=True,
argstr='-s [%f,%f]',
desc='search factor')
search_grid = traits.Either(
traits.Tuple(traits.Float,
traits.Tuple(traits.Float, traits.Float, traits.Float)),
traits.Tuple(traits.Float, traits.Tuple(traits.Float, traits.Float)),
argstr='-g %s',
desc='Translation search grid in mm')
convergence = traits.Tuple(traits.Range(low=1, high=10000, value=10),
traits.Float(1e-6),
traits.Range(low=1, high=100, value=10),
usedefault=True,
argstr='-c [%d,%f,%d]',
desc='convergence')
output_transform = traits.File('initialization.mat',
usedefault=True,
argstr='-o %s',
desc='output file name')
class GrandMeanScalingInputSpec(BaseInterfaceInputSpec):
files = traits.List(File(exists=True), mandatory=True)
mask = File(exists=True, desc="3D brain mask")
mean = traits.Float(mandatory=True, desc="grand mean scale value")
class NiiWranglerOutputSpec(TraitedSpec):
dicom_info = traits.List(
mandatory=True,
desc="one dict for each series in the session, in the order they were\
run. each dict should contain at least the series_num (int) and\
the series_desc (str). NiiWrangler writes nifti location here."
)
t1_uni = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="anatomical uni nifti (list in chronological order if repeated)")
t1_inv2 = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="inv2 nifti (list in chronological order if repeated)")
t1_q = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="quantitative t1 nifti (list in chronological order if repeated)"
)
rsfmri = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="rsfmri nifti (list in chronological order if repeated)")
rs_ap = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="rs ap nifti (list in chronological order if repeated)")
rs_pa = OutputMultiPath(
traits.List(File(exists=True)),
mandatory=True,
desc="rs pa (list in chronological order if repeated)")
dwi = traits.List(
traits.Str(),
mandatory=True,
desc="dwi nifti (list in chronological order if repeated).")
dwi_ap = traits.List(
traits.Str(),
mandatory=True,
desc=
"dwi ap nifti for topup (list in chronological order if repeated).")
dwi_pa = traits.List(
traits.Str(),
mandatory=True,
desc=
"dwi pa nifti for topup (list in chronological order if repeated).")
flair = traits.List(
traits.Str(),
mandatory=True,
desc="flair nifti (list in chronological order if repeated).")
ep_TR = traits.Either(traits.Enum("NONE"),
traits.Float(),
value=["NONE"],
mandatory=False,
usedefault=True,
desc="rsfmri TR or 'NONE' if not used.")
ep_rsfmri_echo_spacings = traits.Either(traits.Enum("NONE"),
traits.Float(),
value=["NONE"],
mandatory=False,
usedefault=True,
desc="""
The effective echo spacing of your rsfmri images. Already accounts
for whether or not iPAT (acceleration in the phase direction) was
used. If you're using acceleration, then the EES is not going to
match the 'Echo Spacing' that Siemen's reports in the console.
This value will be derived, if not overridden by the input of the
same name. Please inspect the value after your initial run of the
pipeline to ensure that it's sane.
""")
ep_dwi_echo_spacings = traits.Either(traits.Enum("NONE"),
traits.Float(),
value=["NONE"],
mandatory=False,
usedefault=True,
desc="""
The effective echo spacing of your BOLD images. Already accounts
for whether or not iPAT (acceleration in the phase direction) was
used. If you're using acceleration, then the EES is not going to
match the 'Echo Spacing' that Siemen's reports in the console.
This value will be derived, if not overridden by the input of the
same name. Please inspect the value after your initial run of the
pipeline to ensure that it's sane.
Length must match number of bold images.""")
ep_unwarp_dirs = traits.List(
traits.Enum(
"x",
"x-",
"-x",
"y",
"y-",
"-y",
"z",
"z-",
"-z",
),
mandatory=True,
desc="Length must match number of bold images.")
class TemplateDimensionsInputSpec(BaseInterfaceInputSpec):
t1w_list = InputMultiPath(File(exists=True), mandatory=True, desc='input T1w images')
max_scale = traits.Float(3.0, usedefault=True,
desc='Maximum scaling factor in images to accept')
class CannyEdgeInputSpec(CommandLineInputSpec):
inputVolume = File(desc="Required: input tissue label image", exists=True, argstr="--inputVolume %s")
variance = traits.Float(desc="Variance and Maximum error are used in the Gaussian smoothing of the input image. See itkDiscreteGaussianImageFilter for information on these parameters.", argstr="--variance %f")
upperThreshold = traits.Float(desc="Threshold is the lowest allowed value in the output image. Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero. ", argstr="--upperThreshold %f")
lowerThreshold = traits.Float(desc="Threshold is the lowest allowed value in the output image. Its data type is the same as the data type of the output image. Any values below the Threshold level will be replaced with the OutsideValue parameter value, whose default is zero. ", argstr="--lowerThreshold %f")
outputVolume = traits.Either(traits.Bool, File(), hash_files=False, desc="Required: output image", argstr="--outputVolume %s")
class TractographyInputSpec(MRTrix3BaseInputSpec):
sph_trait = traits.Tuple(
traits.Float,
traits.Float,
traits.Float,
traits.Float,
argstr='%f,%f,%f,%f')
in_file = File(
exists=True,
argstr='%s',
mandatory=True,
position=-2,
desc='input file to be processed')
out_file = File(
'tracked.tck',
argstr='%s',
mandatory=True,
position=-1,
usedefault=True,
desc='output file containing tracks')
algorithm = traits.Enum(
'iFOD2',
'FACT',
'iFOD1',
'Nulldist',
'SD_Stream',
'Tensor_Det',
'Tensor_Prob',
usedefault=True,
argstr='-algorithm %s',
desc='tractography algorithm to be used')
# ROIs processing options
roi_incl = traits.Either(
File(exists=True),
sph_trait,
argstr='-include %s',
desc=('specify an inclusion region of interest, streamlines must'
' traverse ALL inclusion regions to be accepted'))
roi_excl = traits.Either(
File(exists=True),
sph_trait,
argstr='-exclude %s',
desc=('specify an exclusion region of interest, streamlines that'
' enter ANY exclude region will be discarded'))
roi_mask = traits.Either(
File(exists=True),
sph_trait,
argstr='-mask %s',
desc=('specify a masking region of interest. If defined,'
'streamlines exiting the mask will be truncated'))
# Streamlines tractography options
step_size = traits.Float(
argstr='-step %f',
desc=('set the step size of the algorithm in mm (default is 0.1'
' x voxelsize; for iFOD2: 0.5 x voxelsize)'))
angle = traits.Float(
argstr='-angle %f',
desc=('set the maximum angle between successive steps (default '
'is 90deg x stepsize / voxelsize)'))
n_tracks = traits.Int(
argstr='-number %d',
max_ver='0.4',
desc=('set the desired number of tracks. The program will continue'
' to generate tracks until this number of tracks have been '
'selected and written to the output file'))
select = traits.Int(
argstr='-select %d',
min_ver='3',
desc=('set the desired number of tracks. The program will continue'
' to generate tracks until this number of tracks have been '
'selected and written to the output file'))
max_tracks = traits.Int(
argstr='-maxnum %d',
desc=('set the maximum number of tracks to generate. The program '
'will not generate more tracks than this number, even if '
'the desired number of tracks hasn\'t yet been reached '
'(default is 100 x number)'))
max_length = traits.Float(
argstr='-maxlength %f',
desc=('set the maximum length of any track in mm (default is '
'100 x voxelsize)'))
min_length = traits.Float(
argstr='-minlength %f',
desc=('set the minimum length of any track in mm (default is '
'5 x voxelsize)'))
cutoff = traits.Float(
argstr='-cutoff %f',
desc=('set the FA or FOD amplitude cutoff for terminating '
'tracks (default is 0.1)'))
cutoff_init = traits.Float(
argstr='-initcutoff %f',
desc=('set the minimum FA or FOD amplitude for initiating '
'tracks (default is the same as the normal cutoff)'))
n_trials = traits.Int(
argstr='-trials %d',
desc=('set the maximum number of sampling trials at each point'
' (only used for probabilistic tracking)'))
unidirectional = traits.Bool(
argstr='-unidirectional',
desc=('track from the seed point in one direction only '
'(default is to track in both directions)'))
init_dir = traits.Tuple(
traits.Float,
traits.Float,
traits.Float,
argstr='-initdirection %f,%f,%f',
desc=('specify an initial direction for the tracking (this '
'should be supplied as a vector of 3 comma-separated values'))
noprecompt = traits.Bool(
argstr='-noprecomputed',
desc=('do NOT pre-compute legendre polynomial values. Warning: this '
'will slow down the algorithm by a factor of approximately 4'))
power = traits.Int(
argstr='-power %d',
desc=('raise the FOD to the power specified (default is 1/nsamples)'))
n_samples = traits.Int(
4, usedefault=True,
argstr='-samples %d',
desc=('set the number of FOD samples to take per step for the 2nd '
'order (iFOD2) method'))
use_rk4 = traits.Bool(
argstr='-rk4',
desc=('use 4th-order Runge-Kutta integration (slower, but eliminates'
' curvature overshoot in 1st-order deterministic methods)'))
stop = traits.Bool(
argstr='-stop',
desc=('stop propagating a streamline once it has traversed all '
'include regions'))
downsample = traits.Float(
argstr='-downsample %f',
desc='downsample the generated streamlines to reduce output file size')
# Anatomically-Constrained Tractography options
act_file = File(
exists=True,
argstr='-act %s',
desc=('use the Anatomically-Constrained Tractography framework during'
' tracking; provided image must be in the 5TT '
'(five - tissue - type) format'))
backtrack = traits.Bool(
argstr='-backtrack', desc='allow tracks to be truncated')
crop_at_gmwmi = traits.Bool(
argstr='-crop_at_gmwmi',
desc=('crop streamline endpoints more '
'precisely as they cross the GM-WM interface'))
# Tractography seeding options
seed_sphere = traits.Tuple(
traits.Float,
traits.Float,
traits.Float,
traits.Float,
argstr='-seed_sphere %f,%f,%f,%f',
desc='spherical seed')
seed_image = File(
exists=True,
argstr='-seed_image %s',
desc='seed streamlines entirely at random within mask')
seed_rnd_voxel = traits.Tuple(
File(exists=True),
traits.Int(),
argstr='-seed_random_per_voxel %s %d',
xor=['seed_image', 'seed_grid_voxel'],
desc=('seed a fixed number of streamlines per voxel in a mask '
'image; random placement of seeds in each voxel'))
seed_grid_voxel = traits.Tuple(
File(exists=True),
traits.Int(),
argstr='-seed_grid_per_voxel %s %d',
xor=['seed_image', 'seed_rnd_voxel'],
desc=('seed a fixed number of streamlines per voxel in a mask '
'image; place seeds on a 3D mesh grid (grid_size argument '
'is per axis; so a grid_size of 3 results in 27 seeds per'
' voxel)'))
seed_rejection = File(
exists=True,
argstr='-seed_rejection %s',
desc=('seed from an image using rejection sampling (higher '
'values = more probable to seed from'))
seed_gmwmi = File(
exists=True,
argstr='-seed_gmwmi %s',
requires=['act_file'],
desc=('seed from the grey matter - white matter interface (only '
'valid if using ACT framework)'))
seed_dynamic = File(
exists=True,
argstr='-seed_dynamic %s',
desc=('determine seed points dynamically using the SIFT model '
'(must not provide any other seeding mechanism). Note that'
' while this seeding mechanism improves the distribution of'
' reconstructed streamlines density, it should NOT be used '
'as a substitute for the SIFT method itself.'))
max_seed_attempts = traits.Int(
argstr='-max_seed_attempts %d',
desc=('set the maximum number of times that the tracking '
'algorithm should attempt to find an appropriate tracking'
' direction from a given seed point'))
out_seeds = File(
'out_seeds.nii.gz', usedefault=True,
argstr='-output_seeds %s',
desc=('output the seed location of all successful streamlines to'
' a file'))
class TextureMeasureFilterInputSpec(CommandLineInputSpec):
inputVolume = File(exists=True, argstr="--inputVolume %s")
inputMaskVolume = File(exists=True, argstr="--inputMaskVolume %s")
distance = traits.Int(argstr="--distance %d")
insideROIValue = traits.Float(argstr="--insideROIValue %f")
outputFilename = traits.Either(traits.Bool, File(), hash_files=False, argstr="--outputFilename %s")
class GmshInputSpec(CommandLineInputSpec):
unroll_geometry = traits.Bool(argstr='-0',
desc="Output unrolled geometry, then exit")
geometrical_tolerance = traits.Float(argstr='-tol %f',
desc="Set geometrical tolerance")
match_geometries_and_meshes = traits.Bool(
argstr='-match', desc="Match geometries and meshes")
mesh_generation_dimension = traits.Enum(
['1', '2', '3'],
argstr='-%s',
desc='Perform 1D, 2D or 3D mesh generation, then exit')
output_type = traits.Enum(
'msh', [
'msh', 'msh1', 'msh2', 'unv', 'vrml', 'ply2', 'stl', 'mesh', 'bdf',
'cgns', 'p3d', 'diff', 'med'
],
argstr='-format %s',
usedefault=True,
desc=
'Select output mesh format (auto (default), msh, msh1, msh2, unv, vrml, ply2, stl, mesh, bdf, cgns, p3d, diff, med, ...)'
)
version = traits.Enum(['1', '2'], desc='Select msh file version')
uniform_mesh_refinement = traits.Bool(
argstr='-refine', desc="Perform uniform mesh refinement, then exit")
renumber_mesh_elements = traits.Bool(
argstr='-renumber',
desc="Renumber the mesh elements after batch mesh generation")
save_all_elements = traits.Bool(
argstr='-saveall',
desc="Save all elements (discard physical group definitions)")
use_binary_format = traits.Bool(argstr='-bin',
desc="Use binary format when available")
save_vertices_with_parametric_coords = traits.Bool(
argstr='-parametric',
desc="Save vertices with their parametric coordinates")
number_of_subdivisions = traits.Bool(
argstr='-numsubedges',
desc="Set num of subdivisions for high order element display")
meshing_algorithm = traits.Enum("meshadapt",
"del2d",
"front2d",
"delquad",
"del3d",
"front3d",
"mmg3d",
argstr="-algo %s",
desc="operation to perform")
smoothing_steps = traits.Int(argstr='-smooth %d',
desc="Set number of mesh smoothing steps")
mesh_order = traits.Int(argstr='-order %d',
desc="Set mesh order (1, ..., 5)")
highorder_optimize = traits.Bool(argstr='-hoOptimize',
desc="Optimize high order meshes")
highorder_element_quality = traits.Float(
argstr='-hoMindisto %d',
desc="Min high-order element quality before optim (0.0->1.0)")
highorder_num_layers = traits.Int(
argstr='-hoNLayers %d',
requires=["highorder_optimize"],
desc="Number of high order element layers to optimize")
highorder_elasticity = traits.Float(
argstr='-hoElasticity %d',
desc="Poisson ration for elasticity analogy (nu in [-1.0,0.5])")
optimize_netgen = traits.Bool(
argstr='-optimize_netgen',
desc="Optimize quality of tetrahedral elements")
optimize_lloyd = traits.Bool(
argstr='-optimize_lloyd',
desc="Optimize 2D meshes using Lloyd algorithm")
generate_microstructure = traits.Bool(
argstr='-microstructure', desc="Generate polycrystal Voronoi geometry")
element_size_scaling_factor = traits.Float(
argstr='-clscale %d',
desc="Set global mesh element size scaling factor")
min_element_size = traits.Float(argstr='-clmin %d',
desc="Set minimum mesh element size")
max_element_size = traits.Float(argstr='-clmax %d',
desc="Set maximum mesh element size")
max_anisotropy = traits.Float(
argstr='-anisoMax %d',
desc="Set maximum anisotropy (only used in bamg for now)")
smoothing_ratio = traits.Float(
argstr='-smoothRatio %d',
desc=
"Set smoothing ratio between mesh sizes at nodes of a same edge (only used in bamg)"
)
compute_element_sizes_from_curvature = traits.Bool(
argstr='-clcurv',
desc="Automatically compute element sizes from curvatures")
accuracy_of_LCFIELD_for_1D_mesh = traits.Bool(
argstr='-epslc1d',
desc="Set accuracy of evaluation of LCFIELD for 1D mesh")
background_mesh_file = File(exists=True,
argstr="-bgm %s",
desc="Load background mesh from file")
run_consistency_checks_on_mesh = traits.Bool(
argstr='-check', desc="Perform various consistency checks on mesh")
ignore_partitions_boundaries = traits.Bool(
argstr='-ignorePartBound', desc="Ignore partitions boundaries")
create_new = traits.Bool(argstr='-new',
desc="Create new model before merge next file")
merge_next = traits.Bool(argstr='-merge', desc="Merge next files")
in_files = InputMultiPath(File(exists=True),
argstr="%s",
position=-2,
mandatory=True)
output_type = traits.Enum('msh',
['stl', 'msh', 'wrl', 'vrml', 'fs', 'off'],
usedefault=True,
desc='The output type to save the file as.')
out_filename = File(genfile=True,
argstr="-o %s",
position=-1,
desc='Specify output file name')
class GradientAnisotropicDiffusionImageFilterInputSpec(CommandLineInputSpec):
inputVolume = File(desc="Required: input image", exists=True, argstr="--inputVolume %s")
numberOfIterations = traits.Int(desc="Optional value for number of Iterations", argstr="--numberOfIterations %d")
timeStep = traits.Float(desc="Time step for diffusion process", argstr="--timeStep %f")
conductance = traits.Float(desc="Conductance for diffusion process", argstr="--conductance %f")
outputVolume = traits.Either(traits.Bool, File(), hash_files=False, desc="Required: output image", argstr="--outputVolume %s")
class ComputeQI2OutputSpec(TraitedSpec):
qi2 = traits.Float(desc="computed QI2 value")
out_file = File(desc="output plot: noise fit")
class StreamlineTrackInputSpec(CommandLineInputSpec):
in_file = File(exists=True, argstr='%s', mandatory=True, position=-2, desc='the image containing the source data.' \
'The type of data required depends on the type of tracking as set in the preceeding argument. For DT methods, ' \
'the base DWI are needed. For SD methods, the SH harmonic coefficients of the FOD are needed.')
seed_file = File(exists=True,
argstr='-seed %s',
position=2,
desc='seed file')
seed_spec = traits.List(
traits.Float,
desc='seed specification in mm and radius (x y z r)',
position=2,
argstr='-seed %s',
minlen=4,
maxlen=4,
sep=',',
units='mm')
include_file = File(exists=True,
argstr='-include %s',
position=2,
desc='inclusion file')
include_spec = traits.List(
traits.Float,
desc='inclusion specification in mm and radius (x y z r)',
position=2,
argstr='-seed %s',
minlen=4,
maxlen=4,
sep=',',
units='mm')
exclude_file = File(exists=True,
argstr='-exclude %s',
position=2,
desc='exclusion file')
exclude_spec = traits.List(
traits.Float,
desc='exclusion specification in mm and radius (x y z r)',
position=2,
argstr='-seed %s',
minlen=4,
maxlen=4,
sep=',',
units='mm')
mask_file = File(exists=True,
argstr='-exclude %s',
position=2,
desc='mask file. Only tracks within mask.')
mask_spec = traits.List(
traits.Float,
desc=
'Mask specification in mm and radius (x y z r). Tracks will be terminated when they leave the ROI.',
position=2,
argstr='-seed %s',
minlen=4,
maxlen=4,
sep=',',
units='mm')
inputmodel = traits.Enum('DT_STREAM',
'SD_PROB',
'SD_STREAM',
argstr='%s',
desc='input model type',
usedefault=True,
position=-3)
stop = traits.Bool(
argstr='-gzip',
desc="stop track as soon as it enters any of the include regions.")
do_not_precompute = traits.Bool(
argstr='-noprecomputed',
desc=
"Turns off precomputation of the legendre polynomial values. Warning: this will slow down the algorithm by a factor of approximately 4."
)
unidirectional = traits.Bool(
argstr='-unidirectional',
desc=
"Track from the seed point in one direction only (default is to track in both directions)."
)
no_mask_interpolation = traits.Bool(
argstr='-nomaskinterp',
desc="Turns off trilinear interpolation of mask images.")
step_size = traits.Float(
argstr='-step %s',
units='mm',
desc="Set the step size of the algorithm in mm (default is 0.2).")
minimum_radius_of_curvature = traits.Float(
argstr='-curvature %s',
units='mm',
desc=
"Set the minimum radius of curvature (default is 2 mm for DT_STREAM, 0 for SD_STREAM, 1 mm for SD_PROB and DT_PROB)"
)
desired_number_of_tracks = traits.Int(argstr='-number %d', desc='Sets the desired number of tracks.' \
'The program will continue to generate tracks until this number of tracks have been selected and written to the output file' \
'(default is 100 for *_STREAM methods, 1000 for *_PROB methods).')
maximum_number_of_tracks = traits.Int(argstr='-maxnum %d', desc='Sets the maximum number of tracks to generate.' \
"The program will not generate more tracks than this number, even if the desired number of tracks hasn't yet been reached" \
'(default is 100 x number).')
minimum_tract_length = traits.Float(
argstr='-minlength %s',
units='mm',
desc=
"Sets the minimum length of any track in millimeters (default is 10 mm)."
)
maximum_tract_length = traits.Float(
argstr='-length %s',
units='mm',
desc=
"Sets the maximum length of any track in millimeters (default is 200 mm)."
)
cutoff_value = traits.Float(
argstr='-cutoff %s',
units='NA',
desc=
"Set the FA or FOD amplitude cutoff for terminating tracks (default is 0.1)."
)
initial_cutoff_value = traits.Float(
argstr='-initcutoff %s',
units='NA',
desc=
"Sets the minimum FA or FOD amplitude for initiating tracks (default is twice the normal cutoff)."
)
initial_direction = traits.List(
traits.Int,
desc='Specify the initial tracking direction as a vector',
argstr='-initdirection %s',
minlen=2,
maxlen=2,
units='voxels')
out_file = File(argstr='%s',
position=-1,
genfile=True,
desc='output data file')
class EnsureSizeInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, copyfile=False, mandatory=True, desc='input image')
in_mask = File(exists=True, copyfile=False, desc='input mask')
pixel_size = traits.Float(2.0, usedefault=True,
desc='desired pixel size (mm)')
class MittensBaseTransitionProbabilityCalcSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc=('input diffusion data'))
in_bval = File(exists=True, mandatory=True, desc=('input b-values table'))
in_bvec = File(exists=True, mandatory=True, desc=('input b-vectors table'))
b0_thres = traits.Float(700, usedefault=True, desc=('b0 threshold'))
out_prefix = traits.Str(desc=('output prefix for file names'))
class FieldToRadSInputSpec(BaseInterfaceInputSpec):
in_file = File(exists=True, mandatory=True, desc='input fieldmap')
fmap_range = traits.Float(desc='range of input field map')
