class ModelRegInput(BaseInterfaceInputSpec):
copes = InputMultiPath(File(exists=True))
varcopes = InputMultiPath(File(exists=True))
sumsquares = InputMultiPath(File(exists=True))
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 _UnzipJoinedSurfacesInputSpec(BaseInterfaceInputSpec):
in_files = traits.List(
InputMultiPath(File(exists=True),
mandatory=True,
desc='input GIfTI files'))
class ApplymultipleXfmInputSpec(BaseInterfaceInputSpec):
in_files = InputMultiPath(File(desc='files to be registered', mandatory = True, exists = True))
xfm_file = File(mandatory=True, exists=True)
reference = File(mandatory = True, exists = True)
class RegistrationInputSpec(ANTSCommandInputSpec):
dimension = traits.Enum(3,
2,
argstr='--dimensionality %d',
usedefault=True,
desc='image dimension (2 or 3)')
fixed_image = InputMultiPath(
File(exists=True),
mandatory=True,
desc=
'image to apply transformation to (generally a coregistered functional)'
)
fixed_image_mask = File(argstr='%s',
exists=True,
desc='mask used to limit registration region')
moving_image = InputMultiPath(
File(exists=True),
mandatory=True,
desc=
'image to apply transformation to (generally a coregistered functional)'
)
moving_image_mask = File(requires=['fixed_image_mask'],
exists=True,
desc='')
initial_moving_transform = File(argstr='%s',
exists=True,
desc='',
xor=['initial_moving_transform_com'])
invert_initial_moving_transform = traits.Bool(
default=False,
requires=["initial_moving_transform"],
desc='',
xor=['initial_moving_transform_com'])
initial_moving_transform_com = traits.Enum(
0,
1,
2,
argstr='%s',
default=0,
xor=['initial_moving_transform'],
desc="Use center of mass for moving transform")
metric_item_trait = traits.Enum("CC", "MeanSquares", "Demons", "GC", "MI",
"Mattes")
metric_stage_trait = traits.Either(metric_item_trait,
traits.List(metric_item_trait))
metric = traits.List(
metric_stage_trait,
mandatory=True,
desc='the metric(s) to use for each stage. '
'Note that multiple metrics per stage are not supported '
'in ANTS 1.9.1 and earlier.')
metric_weight_item_trait = traits.Float(1.0)
metric_weight_stage_trait = traits.Either(
metric_weight_item_trait, traits.List(metric_weight_item_trait))
metric_weight = traits.List(metric_weight_stage_trait,
value=[1.0],
usedefault=True,
requires=['metric'],
mandatory=True,
desc='the metric weight(s) for each stage. '
'The weights must sum to 1 per stage.')
radius_bins_item_trait = traits.Int(5)
radius_bins_stage_trait = traits.Either(
radius_bins_item_trait, traits.List(radius_bins_item_trait))
radius_or_number_of_bins = traits.List(
radius_bins_stage_trait,
value=[5],
usedefault=True,
requires=['metric_weight'],
desc='the number of bins in each stage for the MI and Mattes metric, '
'the radius for other metrics')
sampling_strategy_item_trait = traits.Enum("None", "Regular", "Random",
None)
sampling_strategy_stage_trait = traits.Either(
sampling_strategy_item_trait,
traits.List(sampling_strategy_item_trait))
sampling_strategy = traits.List(
trait=sampling_strategy_stage_trait,
requires=['metric_weight'],
desc='the metric sampling strategy (strategies) for each stage')
sampling_percentage_item_trait = traits.Either(
traits.Range(low=0.0, high=1.0), None)
sampling_percentage_stage_trait = traits.Either(
sampling_percentage_item_trait,
traits.List(sampling_percentage_item_trait))
sampling_percentage = traits.List(
trait=sampling_percentage_stage_trait,
requires=['sampling_strategy'],
desc="the metric sampling percentage(s) to use for each stage")
use_estimate_learning_rate_once = traits.List(traits.Bool(), desc='')
use_histogram_matching = traits.Either(traits.Bool,
traits.List(
traits.Bool(argstr='%s')),
default=True,
usedefault=True)
interpolation = traits.Enum(
'Linear',
'NearestNeighbor',
'CosineWindowedSinc',
'WelchWindowedSinc',
'HammingWindowedSinc',
'LanczosWindowedSinc',
'BSpline',
# 'MultiLabel',
# 'Gaussian',
# 'BSpline',
argstr='%s',
usedefault=True)
# MultiLabel[<sigma=imageSpacing>,<alpha=4.0>]
# Gaussian[<sigma=imageSpacing>,<alpha=1.0>]
# BSpline[<order=3>]
write_composite_transform = traits.Bool(
argstr='--write-composite-transform %d',
default=False,
usedefault=True,
desc='')
collapse_output_transforms = traits.Bool(
argstr='--collapse-output-transforms %d',
default=True,
usedefault=True, # This should be true for explicit completeness
desc=('Collapse output transforms. Specifically, enabling this option '
'combines all adjacent linear transforms and composes all '
'adjacent displacement field transforms before writing the '
'results to disk.'))
transforms = traits.List(traits.Enum(
'Rigid', 'Affine', 'CompositeAffine', 'Similarity', 'Translation',
'BSpline', 'GaussianDisplacementField', 'TimeVaryingVelocityField',
'TimeVaryingBSplineVelocityField', 'SyN', 'BSplineSyN', 'Exponential',
'BSplineExponential'),
argstr='%s',
mandatory=True)
# TODO: transform_parameters currently supports rigid, affine, composite
# affine, translation, bspline, gaussian displacement field (gdf), and SyN
# -----ONLY-----!
transform_parameters = traits.List(
traits.Either(
traits.Float(),
traits.Tuple(traits.Float()),
traits.Tuple(
traits.Float(), # gdf & syn
traits.Float(),
traits.Float()),
traits.Tuple(
traits.Float(), # BSplineSyn
traits.Int(),
traits.Int(),
traits.Int())))
# Convergence flags
number_of_iterations = traits.List(traits.List(traits.Int()))
smoothing_sigmas = traits.List(traits.List(traits.Float()), mandatory=True)
sigma_units = traits.List(traits.Enum('mm', 'vox'),
requires=['smoothing_sigmas'],
desc="units for smoothing sigmas")
shrink_factors = traits.List(traits.List(traits.Int()), mandatory=True)
convergence_threshold = traits.List(trait=traits.Float(),
value=[1e-6],
minlen=1,
requires=['number_of_iterations'],
usedefault=True)
convergence_window_size = traits.List(trait=traits.Int(),
value=[10],
minlen=1,
requires=['convergence_threshold'],
usedefault=True)
# Output flags
output_transform_prefix = traits.Str("transform",
usedefault=True,
argstr="%s",
desc="")
output_warped_image = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="")
output_inverse_warped_image = traits.Either(
traits.Bool,
File(),
hash_files=False,
requires=['output_warped_image'],
desc="")
winsorize_upper_quantile = traits.Range(
low=0.0,
high=1.0,
value=1.0,
argstr='%s',
usedefault=True,
desc="The Upper quantile to clip image ranges")
winsorize_lower_quantile = traits.Range(
low=0.0,
high=1.0,
value=0.0,
argstr='%s',
usedefault=True,
desc="The Lower quantile to clip image ranges")
collapse_linear_transforms_to_fixed_image_header = traits.Bool(
argstr='%s', default=False, usedefault=True, desc='')
class BRAINSDemonWarpInputSpec(CommandLineInputSpec):
movingVolume = File(desc="Required: input moving image",
exists=True,
argstr="--movingVolume %s")
fixedVolume = File(desc="Required: input fixed (target) image",
exists=True,
argstr="--fixedVolume %s")
inputPixelType = traits.Enum(
"float",
"short",
"ushort",
"int",
"uchar",
desc=
"Input volumes will be typecast to this format: float|short|ushort|int|uchar",
argstr="--inputPixelType %s")
outputVolume = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"Required: output resampled moving image (will have the same physical space as the fixedVolume).",
argstr="--outputVolume %s")
outputDisplacementFieldVolume = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"Output deformation field vector image (will have the same physical space as the fixedVolume).",
argstr="--outputDisplacementFieldVolume %s")
outputPixelType = traits.Enum(
"float",
"short",
"ushort",
"int",
"uchar",
desc=
"outputVolume will be typecast to this format: float|short|ushort|int|uchar",
argstr="--outputPixelType %s")
interpolationMode = traits.Enum(
"NearestNeighbor",
"Linear",
"ResampleInPlace",
"BSpline",
"WindowedSinc",
"Hamming",
"Cosine",
"Welch",
"Lanczos",
"Blackman",
desc=
"Type of interpolation to be used when applying transform to moving volume. Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc",
argstr="--interpolationMode %s")
registrationFilterType = traits.Enum(
"Demons",
"FastSymmetricForces",
"Diffeomorphic",
desc=
"Registration Filter Type: Demons|FastSymmetricForces|Diffeomorphic",
argstr="--registrationFilterType %s")
smoothDisplacementFieldSigma = traits.Float(
desc=
"A gaussian smoothing value to be applied to the deformation feild at each iteration.",
argstr="--smoothDisplacementFieldSigma %f")
numberOfPyramidLevels = traits.Int(
desc=
"Number of image pyramid levels to use in the multi-resolution registration.",
argstr="--numberOfPyramidLevels %d")
minimumFixedPyramid = InputMultiPath(
traits.Int,
desc=
"The shrink factor for the first level of the fixed image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)",
sep=",",
argstr="--minimumFixedPyramid %s")
minimumMovingPyramid = InputMultiPath(
traits.Int,
desc=
"The shrink factor for the first level of the moving image pyramid. (i.e. start at 1/16 scale, then 1/8, then 1/4, then 1/2, and finally full scale)",
sep=",",
argstr="--minimumMovingPyramid %s")
arrayOfPyramidLevelIterations = InputMultiPath(
traits.Int,
desc="The number of iterations for each pyramid level",
sep=",",
argstr="--arrayOfPyramidLevelIterations %s")
histogramMatch = traits.Bool(
desc=
"Histogram Match the input images. This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile.",
argstr="--histogramMatch ")
numberOfHistogramBins = traits.Int(desc="The number of histogram levels",
argstr="--numberOfHistogramBins %d")
numberOfMatchPoints = traits.Int(
desc="The number of match points for histrogramMatch",
argstr="--numberOfMatchPoints %d")
medianFilterSize = InputMultiPath(
traits.Int,
desc=
"Median filter radius in all 3 directions. When images have a lot of salt and pepper noise, this step can improve the registration.",
sep=",",
argstr="--medianFilterSize %s")
initializeWithDisplacementField = File(
desc="Initial deformation field vector image file name",
exists=True,
argstr="--initializeWithDisplacementField %s")
initializeWithTransform = File(desc="Initial Transform filename",
exists=True,
argstr="--initializeWithTransform %s")
maskProcessingMode = traits.Enum(
"NOMASK",
"ROIAUTO",
"ROI",
"BOBF",
desc=
"What mode to use for using the masks: NOMASK|ROIAUTO|ROI|BOBF. If ROIAUTO is choosen, then the mask is implicitly defined using a otsu forground and hole filling algorithm. Where the Region Of Interest mode uses the masks to define what parts of the image should be used for computing the deformation field. Brain Only Background Fill uses the masks to pre-process the input images by clipping and filling in the background with a predefined value.",
argstr="--maskProcessingMode %s")
fixedBinaryVolume = File(
desc="Mask filename for desired region of interest in the Fixed image.",
exists=True,
argstr="--fixedBinaryVolume %s")
movingBinaryVolume = File(
desc=
"Mask filename for desired region of interest in the Moving image.",
exists=True,
argstr="--movingBinaryVolume %s")
lowerThresholdForBOBF = traits.Int(
desc="Lower threshold for performing BOBF",
argstr="--lowerThresholdForBOBF %d")
upperThresholdForBOBF = traits.Int(
desc="Upper threshold for performing BOBF",
argstr="--upperThresholdForBOBF %d")
backgroundFillValue = traits.Int(
desc="Replacement value to overwrite background when performing BOBF",
argstr="--backgroundFillValue %d")
seedForBOBF = InputMultiPath(
traits.Int,
desc="coordinates in all 3 directions for Seed when performing BOBF",
sep=",",
argstr="--seedForBOBF %s")
neighborhoodForBOBF = InputMultiPath(
traits.Int,
desc=
"neighborhood in all 3 directions to be included when performing BOBF",
sep=",",
argstr="--neighborhoodForBOBF %s")
outputDisplacementFieldPrefix = traits.Str(
desc=
"Displacement field filename prefix for writing separate x, y, and z component images",
argstr="--outputDisplacementFieldPrefix %s")
outputCheckerboardVolume = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"Genete a checkerboard image volume between the fixedVolume and the deformed movingVolume.",
argstr="--outputCheckerboardVolume %s")
checkerboardPatternSubdivisions = InputMultiPath(
traits.Int,
desc="Number of Checkerboard subdivisions in all 3 directions",
sep=",",
argstr="--checkerboardPatternSubdivisions %s")
outputNormalized = traits.Bool(
desc=
"Flag to warp and write the normalized images to output. In normalized images the image values are fit-scaled to be between 0 and the maximum storage type value.",
argstr="--outputNormalized ")
outputDebug = traits.Bool(
desc="Flag to write debugging images after each step.",
argstr="--outputDebug ")
gradient_type = traits.Enum(
"0",
"1",
"2",
desc=
"Type of gradient used for computing the demons force (0 is symmetrized, 1 is fixed image, 2 is moving image)",
argstr="--gradient_type %s")
upFieldSmoothing = traits.Float(
desc="Smoothing sigma for the update field at each iteration",
argstr="--upFieldSmoothing %f")
max_step_length = traits.Float(
desc="Maximum length of an update vector (0: no restriction)",
argstr="--max_step_length %f")
use_vanilla_dem = traits.Bool(desc="Run vanilla demons algorithm",
argstr="--use_vanilla_dem ")
gui = traits.Bool(desc="Display intermediate image volumes for debugging",
argstr="--gui ")
promptUser = traits.Bool(
desc=
"Prompt the user to hit enter each time an image is sent to the DebugImageViewer",
argstr="--promptUser ")
numberOfBCHApproximationTerms = traits.Int(
desc="Number of terms in the BCH expansion",
argstr="--numberOfBCHApproximationTerms %d")
numberOfThreads = traits.Int(
desc="Explicitly specify the maximum number of threads to use.",
argstr="--numberOfThreads %d")
class ModelMakerInputSpec(CommandLineInputSpec):
InputVolume = File(
position=-1,
desc=
"Input label map. The Input Volume drop down menu is populated with the label map volumes that are present in the scene, select one from which to generate models.",
exists=True,
argstr="%s",
)
color = File(
desc="Color table to make labels to colors and objects",
exists=True,
argstr="--color %s",
)
modelSceneFile = traits.Either(
traits.Bool,
InputMultiPath(File()),
hash_files=False,
desc=
"Generated models, under a model hierarchy node. Models are imported into Slicer under a model hierarchy node, and their colors are set by the color table associated with the input label map volume. The model hierarchy node must be created before running the model maker, by selecting Create New ModelHierarchy from the Models drop down menu. If you're running from the command line, a model hierarchy node in a new mrml scene will be created for you.",
argstr="--modelSceneFile %s...",
)
name = traits.Str(
desc=
"Name to use for this model. Any text entered in the entry box will be the starting string for the created model file names. The label number and the color name will also be part of the file name. If making multiple models, use this as a prefix to the label and color name.",
argstr="--name %s",
)
generateAll = traits.Bool(
desc=
"Generate models for all labels in the input volume. select this option if you want to create all models that correspond to all values in a labelmap volume (using the Joint Smoothing option below is useful with this option). Ignores Labels, Start Label, End Label settings. Skips label 0.",
argstr="--generateAll ",
)
labels = InputMultiPath(
traits.Int,
desc=
"A comma separated list of label values from which to make models. f you specify a list of Labels, it will override any start/end label settings. If you click Generate All Models it will override the list of labels and any start/end label settings.",
sep=",",
argstr="--labels %s",
)
start = traits.Int(
desc=
"If you want to specify a continuous range of labels from which to generate models, enter the lower label here. Voxel value from which to start making models. Used instead of the label list to specify a range (make sure the label list is empty or it will over ride this).",
argstr="--start %d",
)
end = traits.Int(
desc=
"If you want to specify a continuous range of labels from which to generate models, enter the higher label here. Voxel value up to which to continue making models. Skip any values with zero voxels.",
argstr="--end %d",
)
skipUnNamed = traits.Bool(
desc=
"Select this to not generate models from labels that do not have names defined in the color look up table associated with the input label map. If true, only models which have an entry in the color table will be generated. If false, generate all models that exist within the label range.",
argstr="--skipUnNamed ",
)
jointsmooth = traits.Bool(
desc=
"This will ensure that all resulting models fit together smoothly, like jigsaw puzzle pieces. Otherwise the models will be smoothed independently and may overlap.",
argstr="--jointsmooth ",
)
smooth = traits.Int(
desc=
"Here you can set the number of smoothing iterations for Laplacian smoothing, or the degree of the polynomial approximating the windowed Sinc function. Use 0 if you wish no smoothing. ",
argstr="--smooth %d",
)
filtertype = traits.Enum(
"Sinc",
"Laplacian",
desc=
"You can control the type of smoothing done on the models by selecting a filter type of either Sinc or Laplacian.",
argstr="--filtertype %s",
)
decimate = traits.Float(
desc=
"Chose the target reduction in number of polygons as a decimal percentage (between 0 and 1) of the number of polygons. Specifies the percentage of triangles to be removed. For example, 0.1 means 10% reduction and 0.9 means 90% reduction.",
argstr="--decimate %f",
)
splitnormals = traits.Bool(
desc=
"Splitting normals is useful for visualizing sharp features. However it creates holes in surfaces which affects measurements.",
argstr="--splitnormals ",
)
pointnormals = traits.Bool(
desc=
"Turn this flag on if you wish to calculate the normal vectors for the points.",
argstr="--pointnormals ",
)
pad = traits.Bool(
desc=
"Pad the input volume with zero value voxels on all 6 faces in order to ensure the production of closed surfaces. Sets the origin translation and extent translation so that the models still line up with the unpadded input volume.",
argstr="--pad ",
)
saveIntermediateModels = traits.Bool(
desc=
"You can save a copy of the models after each of the intermediate steps (marching cubes, smoothing, and decimation if not joint smoothing, otherwise just after decimation). These intermediate models are not saved in the mrml file, you have to load them manually after turning off deleting temporary files in they python console (View ->Python Interactor) using the following command slicer.modules.modelmaker.cliModuleLogic().DeleteTemporaryFilesOff().",
argstr="--saveIntermediateModels ",
)
debug = traits.Bool(
desc=
"turn this flag on in order to see debugging output (look in the Error Log window that is accessed via the View menu)",
argstr="--debug ",
)
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 DicomInfoInputSpec(BaseInterfaceInputSpec):
files = InputMultiPath(
traits.Either(traits.List(File(exists=True)), File(exists=True)),
mandatory=True,
desc="a list of dicom files from which to extract data",
copyfile=False)
class IntraModalMergeInputSpec(BaseInterfaceInputSpec):
in_files = InputMultiPath(File(exists=True), mandatory=True,
desc='input files')
hmc = traits.Bool(True, usedefault=True)
zero_based_avg = traits.Bool(True, usedefault=True)
to_ras = traits.Bool(True, usedefault=True)
class GenerateLabelMapFromProbabilityMapInputSpec(CommandLineInputSpec):
inputVolumes = InputMultiPath(File(exists=True), argstr = "--inputVolumes %s...")
outputLabelVolume = File( exists = True,argstr = "--outputLabelVolume %s")
numberOfThreads = traits.Int( argstr = "--numberOfThreads %d")
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 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 EMSegmentCommandLineInputSpec(CommandLineInputSpec):
mrmlSceneFileName = File(
desc="Active MRML scene that contains EMSegment algorithm parameters.",
exists=True,
argstr="--mrmlSceneFileName %s")
resultVolumeFileName = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"The file name that the segmentation result volume will be written to.",
argstr="--resultVolumeFileName %s")
targetVolumeFileNames = InputMultiPath(
File(exists=True),
desc=
"File names of target volumes (to be segmented). The number of target images must be equal to the number of target images specified in the parameter set, and these images must be spatially aligned.",
argstr="--targetVolumeFileNames %s...")
intermediateResultsDirectory = Directory(
desc=
"Directory where EMSegmenter will write intermediate data (e.g., aligned atlas data).",
exists=True,
argstr="--intermediateResultsDirectory %s")
parametersMRMLNodeName = traits.Str(
desc=
"The name of the EMSegment parameters node within the active MRML scene. Leave blank for default.",
argstr="--parametersMRMLNodeName %s")
disableMultithreading = traits.Int(
desc=
"Disable multithreading for the EMSegmenter algorithm only! Preprocessing might still run in multi-threaded mode. -1: Do not overwrite default value. 0: Disable. 1: Enable.",
argstr="--disableMultithreading %d")
dontUpdateIntermediateData = traits.Int(
desc=
"Disable update of intermediate results. -1: Do not overwrite default value. 0: Disable. 1: Enable.",
argstr="--dontUpdateIntermediateData %d")
verbose = traits.Bool(desc="Enable verbose output.", argstr="--verbose ")
loadTargetCentered = traits.Bool(desc="Read target files centered.",
argstr="--loadTargetCentered ")
loadAtlasNonCentered = traits.Bool(desc="Read atlas files non-centered.",
argstr="--loadAtlasNonCentered ")
taskPreProcessingSetting = traits.Str(
desc="Specifies the different task parameter. Leave blank for default.",
argstr="--taskPreProcessingSetting %s")
keepTempFiles = traits.Bool(
desc=
"If flag is set then at the end of command the temporary files are not removed",
argstr="--keepTempFiles ")
resultStandardVolumeFileName = File(
desc=
"Used for testing. Compare segmentation results to this image and return EXIT_FAILURE if they do not match.",
exists=True,
argstr="--resultStandardVolumeFileName %s")
dontWriteResults = traits.Bool(
desc=
"Used for testing. Don't actually write the resulting labelmap to disk.",
argstr="--dontWriteResults ")
generateEmptyMRMLSceneAndQuit = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"Used for testing. Only write a scene with default mrml parameters.",
argstr="--generateEmptyMRMLSceneAndQuit %s")
resultMRMLSceneFileName = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"Write out the MRML scene after command line substitutions have been made.",
argstr="--resultMRMLSceneFileName %s")
disableCompression = traits.Bool(
desc="Don't use compression when writing result image to disk.",
argstr="--disableCompression ")
atlasVolumeFileNames = InputMultiPath(
File(exists=True),
desc=
"Use an alternative atlas to the one that is specified by the mrml file - note the order matters ! ",
argstr="--atlasVolumeFileNames %s...")
registrationPackage = traits.Str(
desc=
"specify the registration package for preprocessing (CMTK or BRAINS or PLASTIMATCH or DEMONS)",
argstr="--registrationPackage %s")
registrationAffineType = traits.Int(
desc=
"specify the accuracy of the affine registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate",
argstr="--registrationAffineType %d")
registrationDeformableType = traits.Int(
desc=
"specify the accuracy of the deformable registration. -2: Do not overwrite default, -1: Test, 0: Disable, 1: Fast, 2: Accurate",
argstr="--registrationDeformableType %d")
class CheckRTStructuresInputSpec(BaseInterfaceInputSpec):
rois = InputMultiPath(File(exists=True), desc='RT structures to check')
dose_file = File(exists=True, desc='Dose file.')
class STAPLEAnalysisInputSpec(CommandLineInputSpec):
inputDimension = traits.Int(desc="Required: input image Dimension 2 or 3", argstr="--inputDimension %d")
inputLabelVolume = InputMultiPath(File(exists=True), desc="Required: input label volume", argstr="--inputLabelVolume %s...")
outputVolume = traits.Either(traits.Bool, File(), hash_files=False, desc="Required: output image", argstr="--outputVolume %s")
class GetRefRTDoseInputSpec(BaseInterfaceInputSpec):
doses = InputMultiPath(Directory(exists=True), desc='RT doses to check')
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 _AddTPMsInputSpec(BaseInterfaceInputSpec):
in_files = InputMultiPath(File(exists=True),
mandatory=True,
desc="input list of ROIs")
indices = traits.List(traits.Int, desc="select specific maps")
class RealignmentReportInput(BaseInterfaceInputSpec):
target_file = File(exists=True)
realign_params = File(exists=True)
displace_params = InputMultiPath(File(exists=True))
class ApplynlinmultiplewarpsInputSpec(BaseInterfaceInputSpec):
in_files = InputMultiPath(File(desc='files to be registered', mandatory=True, exists=True))
ref_file = File(mandatory=True, exists=True)
premat_file = File(mandatory=True, exists=True)
field_file = File(mandatory=True, exists=True)
class RobustTemplateInputSpec(FSTraitedSpec):
# required
in_files = InputMultiPath(
File(exists=True),
mandatory=True,
argstr='--mov %s',
desc=
'input movable volumes to be aligned to common mean/median template')
out_file = File('mri_robust_template_out.mgz',
mandatory=True,
usedefault=True,
argstr='--template %s',
desc='output template volume (final mean/median image)')
auto_detect_sensitivity = traits.Bool(
argstr='--satit',
xor=['outlier_sensitivity'],
mandatory=True,
desc=
'auto-detect good sensitivity (recommended for head or full brain scans)'
)
outlier_sensitivity = traits.Float(
argstr='--sat %.4f',
xor=['auto_detect_sensitivity'],
mandatory=True,
desc=
'set outlier sensitivity manually (e.g. "--sat 4.685" ). Higher values mean '
+ 'less sensitivity.')
# optional
transform_outputs = InputMultiPath(
File(exists=False),
argstr='--lta %s',
desc='output xforms to template (for each input)')
intensity_scaling = traits.Bool(
default_value=False,
argstr='--iscale',
desc='allow also intensity scaling (default off)')
scaled_intensity_outputs = InputMultiPath(
File(exists=False),
argstr='--iscaleout %s',
desc='final intensity scales (will activate --iscale)')
subsample_threshold = traits.Int(
argstr='--subsample %d',
desc='subsample if dim > # on all axes (default no subs.)')
average_metric = traits.Enum(
'median',
'mean',
argstr='--average %d',
desc='construct template from: 0 Mean, 1 Median (default)')
initial_timepoint = traits.Int(
argstr='--inittp %d',
desc='use TP# for spacial init (default random), 0: no init')
fixed_timepoint = traits.Bool(
default_value=False,
argstr='--fixtp',
desc='map everthing to init TP# (init TP is not resampled)')
no_iteration = traits.Bool(
default_value=False,
argstr='--noit',
desc='do not iterate, just create first template')
initial_transforms = InputMultiPath(
File(exists=True),
argstr='--ixforms %s',
desc='use initial transforms (lta) on source')
in_intensity_scales = InputMultiPath(File(exists=True),
argstr='--iscalein %s',
desc='use initial intensity scales')
class ANTSInputSpec(ANTSCommandInputSpec):
dimension = traits.Enum(3,
2,
argstr='%d',
usedefault=False,
position=1,
desc='image dimension (2 or 3)')
fixed_image = InputMultiPath(
File(exists=True),
mandatory=True,
desc=('image to apply transformation to (generally a coregistered '
'functional)'))
moving_image = InputMultiPath(
File(exists=True),
argstr='%s',
mandatory=True,
desc=('image to apply transformation to (generally a coregistered '
'functional)'))
metric = traits.List(traits.Enum('CC', 'MI', 'SMI', 'PR', 'SSD', 'MSQ',
'PSE'),
mandatory=True,
desc='')
metric_weight = traits.List(traits.Float(), requires=['metric'], desc='')
radius = traits.List(traits.Int(), requires=['metric'], desc='')
output_transform_prefix = traits.Str('out',
usedefault=True,
argstr='--output-naming %s',
mandatory=True,
desc='')
transformation_model = traits.Enum('Diff',
'Elast',
'Exp',
'Greedy Exp',
'SyN',
argstr='%s',
mandatory=True,
desc='')
gradient_step_length = traits.Float(requires=['transformation_model'],
desc='')
number_of_time_steps = traits.Float(requires=['gradient_step_length'],
desc='')
delta_time = traits.Float(requires=['number_of_time_steps'], desc='')
symmetry_type = traits.Float(requires=['delta_time'], desc='')
use_histogram_matching = traits.Bool(argstr='%s',
default=True,
usedefault=True)
number_of_iterations = traits.List(traits.Int(),
argstr='--number-of-iterations %s',
sep='x')
smoothing_sigmas = traits.List(traits.Int(),
argstr='--gaussian-smoothing-sigmas %s',
sep='x')
subsampling_factors = traits.List(traits.Int(),
argstr='--subsampling-factors %s',
sep='x')
affine_gradient_descent_option = traits.List(traits.Float(), argstr='%s')
mi_option = traits.List(traits.Int(), argstr='--MI-option %s', sep='x')
regularization = traits.Enum('Gauss', 'DMFFD', argstr='%s', desc='')
regularization_gradient_field_sigma = traits.Float(
requires=['regularization'], desc='')
regularization_deformation_field_sigma = traits.Float(
requires=['regularization'], desc='')
number_of_affine_iterations = traits.List(
traits.Int(), argstr='--number-of-affine-iterations %s', sep='x')
class dtiestimInputSpec(CommandLineInputSpec):
dwi_image = File(desc="DWI image volume (required)",
exists=True,
argstr="--dwi_image %s")
tensor_output = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="Tensor OutputImage",
argstr="--tensor_output %s")
B0 = traits.Either(traits.Bool,
File(),
hash_files=False,
desc="Baseline image, average of all baseline images",
argstr="--B0 %s")
idwi = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"idwi output image. Image with isotropic diffusion-weighted information = geometric mean of diffusion images",
argstr="--idwi %s")
B0_mask_output = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"B0 mask used for the estimation. B0 thresholded either with the -t option value or the automatic OTSU value",
argstr="--B0_mask_output %s")
brain_mask = File(
desc=
"Brain mask. Image where for every voxel == 0 the tensors are not estimated. Be aware that in addition a threshold based masking will be performed by default. If such an additional threshold masking is NOT desired, then use option -t 0.",
exists=True,
argstr="--brain_mask %s")
bad_region_mask = File(
desc=
"Bad region mask. Image where for every voxel > 0 the tensors are not estimated",
exists=True,
argstr="--bad_region_mask %s")
method = traits.Enum(
"lls",
"wls",
"nls",
"ml",
desc=
"Esitmation method (lls:linear least squares, wls:weighted least squares, nls:non-linear least squares, ml:maximum likelihood)",
argstr="--method %s")
correction = traits.Enum(
"none",
"zero",
"abs",
"nearest",
desc=
"Correct the tensors if computed tensor is not semi-definite positive",
argstr="--correction %s")
threshold = traits.Int(
desc=
"Baseline threshold for estimation. If not specified calculated using an OTSU threshold on the baseline image.",
argstr="--threshold %d")
weight_iterations = traits.Int(
desc=
"Number of iterations to recaluate weightings from tensor estimate",
argstr="--weight_iterations %d")
step = traits.Float(
desc="Gradient descent step size (for nls and ml methods)",
argstr="--step %f")
sigma = traits.Float(argstr="--sigma %f")
DTI_double = traits.Bool(
desc=
"Tensor components are saved as doubles (cannot be visualized in Slicer)",
argstr="--DTI_double ")
verbose = traits.Bool(desc="produce verbose output", argstr="--verbose ")
defaultTensor = InputMultiPath(
traits.Float,
desc=
"Default tensor used if estimated tensor is below a given threshold",
sep=",",
argstr="--defaultTensor %s")
shiftNeg = traits.Bool(
desc=
"Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). This is the same option as the one available in DWIToDTIEstimation in Slicer (but instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues",
argstr="--shiftNeg ")
shiftNegCoeff = traits.Float(
desc=
"Shift eigenvalues so all are positive (accounts for bad tensors related to noise or acquisition error). Instead of just adding the minimum eigenvalue to all the eigenvalues if it is smaller than 0, we use a coefficient to have stictly positive eigenvalues. Coefficient must be between 1.0 and 1.001 (included).",
argstr="--shiftNegCoeff %f")
class ModelSpecLoaderInputSpec(BaseInterfaceInputSpec):
database_path = Directory(exists=False,
desc='Path to bids database')
model = traits.Either('default', InputMultiPath(File(exists=True)),
desc='Model filename')
selectors = traits.Dict(desc='Limit models to those with matching inputs')
class BRAINSResampleInputSpec(CommandLineInputSpec):
inputVolume = File(argstr="--inputVolume %s",
desc="Image To Warp",
exists=True)
referenceVolume = File(
argstr="--referenceVolume %s",
desc=
"Reference image used only to define the output space. If not specified, the warping is done in the same space as the image to warp.",
exists=True)
outputVolume = traits.Either(traits.Bool,
File(),
argstr="--outputVolume %s",
desc="Resulting deformed image",
hash_files=False)
pixelType = traits.Enum(
"float",
"short",
"ushort",
"int",
"uint",
"uchar",
"binary",
argstr="--pixelType %s",
desc=
"Specifies the pixel type for the input/output images. The \'binary\' pixel type uses a modified algorithm whereby the image is read in as unsigned char, a signed distance map is created, signed distance map is resampled, and then a thresholded image of type unsigned char is written to disk."
)
deformationVolume = File(
argstr="--deformationVolume %s",
desc=
"Displacement Field to be used to warp the image (ITKv3 or earlier)",
exists=True)
warpTransform = File(
argstr="--warpTransform %s",
desc=
"Filename for the BRAINSFit transform (ITKv3 or earlier) or composite transform file (ITKv4)",
exists=True)
interpolationMode = traits.Enum(
"NearestNeighbor",
"Linear",
"ResampleInPlace",
"BSpline",
"WindowedSinc",
"Hamming",
"Cosine",
"Welch",
"Lanczos",
"Blackman",
argstr="--interpolationMode %s",
desc=
"Type of interpolation to be used when applying transform to moving volume. Options are Linear, ResampleInPlace, NearestNeighbor, BSpline, or WindowedSinc"
)
inverseTransform = traits.Bool(
argstr="--inverseTransform ",
desc=
"True/False is to compute inverse of given transformation. Default is false"
)
defaultValue = traits.Float(argstr="--defaultValue %f",
desc="Default voxel value")
gridSpacing = InputMultiPath(
traits.Int,
argstr="--gridSpacing %s",
desc=
"Add warped grid to output image to help show the deformation that occured with specified spacing. A spacing of 0 in a dimension indicates that grid lines should be rendered to fall exactly (i.e. do not allow displacements off that plane). This is useful for makeing a 2D image of grid lines from the 3D space",
sep=",")
numberOfThreads = traits.Int(
argstr="--numberOfThreads %d",
desc="Explicitly specify the maximum number of threads to use.")
class _SurfacesToPointCloudInputSpec(BaseInterfaceInputSpec):
in_files = InputMultiPath(File(exists=True),
mandatory=True,
desc='input GIfTI files')
out_file = File('pointcloud.ply', usedefault=True, desc='output file name')
class ConversionCheckInputSpec(BaseInterfaceInputSpec):
in_file = InputMultiPath(File(), desc='(List of) file that'
' needs to be checked after DICOM to NIFTI conversion')
file_name = traits.Str(desc='Name that the converted file has to match'
' in order to be considered correct.')
class BRAINSFitInputSpec(CommandLineInputSpec):
fixedVolume = File(
desc=
"The fixed image for registration by mutual information optimization.",
exists=True,
argstr="--fixedVolume %s")
movingVolume = File(
desc=
"The moving image for registration by mutual information optimization.",
exists=True,
argstr="--movingVolume %s")
bsplineTransform = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"(optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform. NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS BSpline",
argstr="--bsplineTransform %s")
linearTransform = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"(optional) Filename to which save the estimated transform. NOTE: You must set at least one output object (either a deformed image or a transform. NOTE: USE THIS ONLY IF THE FINAL TRANSFORM IS ---NOT--- BSpline",
argstr="--linearTransform %s")
outputVolume = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"(optional) Output image for registration. NOTE: You must select either the outputTransform or the outputVolume option.",
argstr="--outputVolume %s")
initialTransform = File(
desc=
"Filename of transform used to initialize the registration. This CAN NOT be used with either CenterOfHeadLAlign, MomentsAlign, GeometryAlign, or initialTransform file.",
exists=True,
argstr="--initialTransform %s")
initializeTransformMode = traits.Enum(
"Off",
"useMomentsAlign",
"useCenterOfHeadAlign",
"useGeometryAlign",
"useCenterOfROIAlign",
desc=
"Determine how to initialize the transform center. GeometryAlign on assumes that the center of the voxel lattice of the images represent similar structures. MomentsAlign assumes that the center of mass of the images represent similar structures. useCenterOfHeadAlign attempts to use the top of head and shape of neck to drive a center of mass estimate. Off assumes that the physical space of the images are close, and that centering in terms of the image Origins is a good starting point. This flag is mutually exclusive with the initialTransform flag.",
argstr="--initializeTransformMode %s")
useRigid = traits.Bool(
desc=
"Perform a rigid registration as part of the sequential registration steps. This family of options superceeds the use of transformType if any of them are set.",
argstr="--useRigid ")
useScaleVersor3D = traits.Bool(
desc=
"Perform a ScaleVersor3D registration as part of the sequential registration steps. This family of options superceeds the use of transformType if any of them are set.",
argstr="--useScaleVersor3D ")
useScaleSkewVersor3D = traits.Bool(
desc=
"Perform a ScaleSkewVersor3D registration as part of the sequential registration steps. This family of options superceeds the use of transformType if any of them are set.",
argstr="--useScaleSkewVersor3D ")
useAffine = traits.Bool(
desc=
"Perform an Affine registration as part of the sequential registration steps. This family of options superceeds the use of transformType if any of them are set.",
argstr="--useAffine ")
useBSpline = traits.Bool(
desc=
"Perform a BSpline registration as part of the sequential registration steps. This family of options superceeds the use of transformType if any of them are set.",
argstr="--useBSpline ")
numberOfSamples = traits.Int(
desc=
"The number of voxels sampled for mutual information computation. Increase this for a slower, more careful fit. You can also limit the sampling focus with ROI masks and ROIAUTO mask generation.",
argstr="--numberOfSamples %d")
splineGridSize = InputMultiPath(
traits.Int,
desc=
"The number of subdivisions of the BSpline Grid to be centered on the image space. Each dimension must have at least 3 subdivisions for the BSpline to be correctly computed. ",
sep=",",
argstr="--splineGridSize %s")
numberOfIterations = InputMultiPath(
traits.Int,
desc=
"The maximum number of iterations to try before failing to converge. Use an explicit limit like 500 or 1000 to manage risk of divergence",
sep=",",
argstr="--numberOfIterations %s")
maskProcessingMode = traits.Enum(
"NOMASK",
"ROIAUTO",
"ROI",
desc=
"What mode to use for using the masks. If ROIAUTO is choosen, then the mask is implicitly defined using a otsu forground and hole filling algorithm. The Region Of Interest mode (choose ROI) uses the masks to define what parts of the image should be used for computing the transform.",
argstr="--maskProcessingMode %s")
fixedBinaryVolume = File(
desc="Fixed Image binary mask volume, ONLY FOR MANUAL ROI mode.",
exists=True,
argstr="--fixedBinaryVolume %s")
movingBinaryVolume = File(
desc="Moving Image binary mask volume, ONLY FOR MANUAL ROI mode.",
exists=True,
argstr="--movingBinaryVolume %s")
outputFixedVolumeROI = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"The ROI automatically found in fixed image, ONLY FOR ROIAUTO mode.",
argstr="--outputFixedVolumeROI %s")
outputMovingVolumeROI = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"The ROI automatically found in moving image, ONLY FOR ROIAUTO mode.",
argstr="--outputMovingVolumeROI %s")
outputVolumePixelType = traits.Enum(
"float",
"short",
"ushort",
"int",
"uint",
"uchar",
desc=
"The output image Pixel Type is the scalar datatype for representation of the Output Volume.",
argstr="--outputVolumePixelType %s")
backgroundFillValue = traits.Float(
desc="Background fill value for output image.",
argstr="--backgroundFillValue %f")
maskInferiorCutOffFromCenter = traits.Float(
desc=
"For use with --useCenterOfHeadAlign (and --maskProcessingMode ROIAUTO): the cut-off below the image centers, in millimeters, ",
argstr="--maskInferiorCutOffFromCenter %f")
scaleOutputValues = traits.Bool(
desc=
"If true, and the voxel values do not fit within the minimum and maximum values of the desired outputVolumePixelType, then linearly scale the min/max output image voxel values to fit within the min/max range of the outputVolumePixelType.",
argstr="--scaleOutputValues ")
interpolationMode = traits.Enum(
"NearestNeighbor",
"Linear",
"ResampleInPlace",
"BSpline",
"WindowedSinc",
"Hamming",
"Cosine",
"Welch",
"Lanczos",
"Blackman",
desc=
"Type of interpolation to be used when applying transform to moving volume. Options are Linear, NearestNeighbor, BSpline, WindowedSinc, or ResampleInPlace. The ResampleInPlace option will create an image with the same discrete voxel values and will adjust the origin and direction of the physical space interpretation.",
argstr="--interpolationMode %s")
minimumStepLength = InputMultiPath(
traits.Float,
desc=
"Each step in the optimization takes steps at least this big. When none are possible, registration is complete.",
sep=",",
argstr="--minimumStepLength %s")
translationScale = traits.Float(
desc=
"How much to scale up changes in position compared to unit rotational changes in radians -- decrease this to put more rotation in the search pattern.",
argstr="--translationScale %f")
reproportionScale = traits.Float(
desc=
"ScaleVersor3D 'Scale' compensation factor. Increase this to put more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern. 1.0 works well with a translationScale of 1000.0",
argstr="--reproportionScale %f")
skewScale = traits.Float(
desc=
"ScaleSkewVersor3D Skew compensation factor. Increase this to put more skew in a ScaleSkewVersor3D search pattern. 1.0 works well with a translationScale of 1000.0",
argstr="--skewScale %f")
maxBSplineDisplacement = traits.Float(
desc=
" Sets the maximum allowed displacements in image physical coordinates for BSpline control grid along each axis. A value of 0.0 indicates that the problem should be unbounded. NOTE: This only constrains the BSpline portion, and does not limit the displacement from the associated bulk transform. This can lead to a substantial reduction in computation time in the BSpline optimizer., ",
argstr="--maxBSplineDisplacement %f")
histogramMatch = traits.Bool(
desc=
"Histogram Match the input images. This is suitable for images of the same modality that may have different absolute scales, but the same overall intensity profile. Do NOT use if registering images from different modailties.",
argstr="--histogramMatch ")
numberOfHistogramBins = traits.Int(desc="The number of histogram levels",
argstr="--numberOfHistogramBins %d")
numberOfMatchPoints = traits.Int(desc="the number of match points",
argstr="--numberOfMatchPoints %d")
strippedOutputTransform = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"File name for the rigid component of the estimated affine transform. Can be used to rigidly register the moving image to the fixed image. NOTE: This value is overwritten if either bsplineTransform or linearTransform is set.",
argstr="--strippedOutputTransform %s")
transformType = InputMultiPath(
traits.Str,
desc=
"Specifies a list of registration types to be used. The valid types are, Rigid, ScaleVersor3D, ScaleSkewVersor3D, Affine, and BSpline. Specifiying more than one in a comma separated list will initialize the next stage with the previous results. If registrationClass flag is used, it overrides this parameter setting.",
sep=",",
argstr="--transformType %s")
outputTransform = traits.Either(
traits.Bool,
File(),
hash_files=False,
desc=
"(optional) Filename to which save the (optional) estimated transform. NOTE: You must select either the outputTransform or the outputVolume option.",
argstr="--outputTransform %s")
fixedVolumeTimeIndex = traits.Int(
desc=
"The index in the time series for the 3D fixed image to fit, if 4-dimensional.",
argstr="--fixedVolumeTimeIndex %d")
movingVolumeTimeIndex = traits.Int(
desc=
"The index in the time series for the 3D moving image to fit, if 4-dimensional.",
argstr="--movingVolumeTimeIndex %d")
medianFilterSize = InputMultiPath(
traits.Int,
desc=
"The radius for the optional MedianImageFilter preprocessing in all 3 directions.",
sep=",",
argstr="--medianFilterSize %s")
removeIntensityOutliers = traits.Float(
desc=
"The half percentage to decide outliers of image intensities. The default value is zero, which means no outlier removal. If the value of 0.005 is given, the moduel will throw away 0.005 % of both tails, so 0.01% of intensities in total would be ignored in its statistic calculation. ",
argstr="--removeIntensityOutliers %f")
useCachingOfBSplineWeightsMode = traits.Enum(
"ON",
"OFF",
desc=
"This is a 5x speed advantage at the expense of requiring much more memory. Only relevant when transformType is BSpline.",
argstr="--useCachingOfBSplineWeightsMode %s")
useExplicitPDFDerivativesMode = traits.Enum(
"AUTO",
"ON",
"OFF",
desc=
"Using mode AUTO means OFF for BSplineDeformableTransforms and ON for the linear transforms. The ON alternative uses more memory to sometimes do a better job.",
argstr="--useExplicitPDFDerivativesMode %s")
ROIAutoDilateSize = traits.Float(
desc=
"This flag is only relavent when using ROIAUTO mode for initializing masks. It defines the final dilation size to capture a bit of background outside the tissue region. At setting of 10mm has been shown to help regularize a BSpline registration type so that there is some background constraints to match the edges of the head better.",
argstr="--ROIAutoDilateSize %f")
ROIAutoClosingSize = traits.Float(
desc=
"This flag is only relavent when using ROIAUTO mode for initializing masks. It defines the hole closing size in mm. It is rounded up to the nearest whole pixel size in each direction. The default is to use a closing size of 9mm. For mouse data this value may need to be reset to 0.9 or smaller.",
argstr="--ROIAutoClosingSize %f")
relaxationFactor = traits.Float(
desc=
"Internal debugging parameter, and should probably never be used from the command line. This will be removed in the future.",
argstr="--relaxationFactor %f")
maximumStepLength = traits.Float(
desc=
"Internal debugging parameter, and should probably never be used from the command line. This will be removed in the future.",
argstr="--maximumStepLength %f")
failureExitCode = traits.Int(
desc=
"If the fit fails, exit with this status code. (It can be used to force a successfult exit status of (0) if the registration fails due to reaching the maximum number of iterations.",
argstr="--failureExitCode %d")
writeTransformOnFailure = traits.Bool(
desc=
"Flag to save the final transform even if the numberOfIterations are reached without convergence. (Intended for use when --failureExitCode 0 )",
argstr="--writeTransformOnFailure ")
numberOfThreads = traits.Int(
desc=
"Explicitly specify the maximum number of threads to use. (default is auto-detected)",
argstr="--numberOfThreads %d")
forceMINumberOfThreads = traits.Int(
desc=
"Force the the maximum number of threads to use for non thread safe MI metric. CAUTION: Inconsistent results my arise!",
argstr="--forceMINumberOfThreads %d")
debugLevel = traits.Int(
desc=
"Display debug messages, and produce debug intermediate results. 0=OFF, 1=Minimal, 10=Maximum debugging.",
argstr="--debugLevel %d")
costFunctionConvergenceFactor = traits.Float(
desc=
" From itkLBFGSBOptimizer.h: Set/Get the CostFunctionConvergenceFactor. Algorithm terminates when the reduction in cost function is less than (factor * epsmcj) where epsmch is the machine precision. Typical values for factor: 1e+12 for low accuracy; 1e+7 for moderate accuracy and 1e+1 for extremely high accuracy. 1e+9 seems to work well., ",
argstr="--costFunctionConvergenceFactor %f")
projectedGradientTolerance = traits.Float(
desc=
" From itkLBFGSBOptimizer.h: Set/Get the ProjectedGradientTolerance. Algorithm terminates when the project gradient is below the tolerance. Default lbfgsb value is 1e-5, but 1e-4 seems to work well., ",
argstr="--projectedGradientTolerance %f")
gui = traits.Bool(
desc=
"Display intermediate image volumes for debugging. NOTE: This is not part of the standard build sytem, and probably does nothing on your installation.",
argstr="--gui ")
promptUser = traits.Bool(
desc=
"Prompt the user to hit enter each time an image is sent to the DebugImageViewer",
argstr="--promptUser ")
NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_00 = traits.Bool(
desc="DO NOT USE THIS FLAG",
argstr="--NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_00 ")
NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_01 = traits.Bool(
desc="DO NOT USE THIS FLAG",
argstr="--NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_01 ")
NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_02 = traits.Bool(
desc="DO NOT USE THIS FLAG",
argstr="--NEVER_USE_THIS_FLAG_IT_IS_OUTDATED_02 ")
permitParameterVariation = InputMultiPath(
traits.Int,
desc=
"A bit vector to permit linear transform parameters to vary under optimization. The vector order corresponds with transform parameters, and beyond the end ones fill in as a default. For instance, you can choose to rotate only in x (pitch) with 1,0,0; this is mostly for expert use in turning on and off individual degrees of freedom in rotation, translation or scaling without multiplying the number of transform representations; this trick is probably meaningless when tried with the general affine transform.",
sep=",",
argstr="--permitParameterVariation %s")
costMetric = traits.Enum(
"MMI",
"MSE",
"NC",
"MC",
desc=
"The cost metric to be used during fitting. Defaults to MMI. Options are MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation), MC (Match Cardinality for binary images)",
argstr="--costMetric %s")
writeOutputTransformInFloat = traits.Bool(
desc=
"By default, the output registration transforms (either the output composite transform or each transform component) are written to the disk in double precision. If this flag is ON, the output transforms will be written in single (float) precision. It is especially important if the output transform is a displacement field transform, or it is a composite transform that includes several displacement fields.",
argstr="--writeOutputTransformInFloat ")
class RegistrationInput(BaseInterfaceInputSpec):
means = InputMultiPath(File(exists=True))
masks = InputMultiPath(File(exists=True))
rigids = InputMultiPath(File(exists=True))
method = traits.Enum("ants", "fsl")