def test_meanimage(fsl_output_type=None):
prev_type = set_output_type(fsl_output_type)
files, testdir, origdir, out_ext = create_files_in_directory()
# Get the command
meaner = fsl.MeanImage(in_file="a.nii", out_file="b.nii")
# Test the underlying command
yield assert_equal, meaner.cmd, "fslmaths"
# Test the defualt opstring
yield assert_equal, meaner.cmdline, "fslmaths a.nii -Tmean b.nii"
# Test the other dimensions
cmdline = "fslmaths a.nii -%smean b.nii"
for dim in ["X", "Y", "Z", "T"]:
meaner.inputs.dimension = dim
yield assert_equal, meaner.cmdline, cmdline % dim
# Test the auto naming
meaner = fsl.MeanImage(in_file="a.nii")
yield assert_equal, meaner.cmdline, "fslmaths a.nii -Tmean %s" % os.path.join(testdir, "a_mean%s" % out_ext)
# Clean up our mess
clean_directory(testdir, origdir)
set_output_type(prev_type)
def test_meanimage(create_files_in_directory):
files, testdir, out_ext = create_files_in_directory
# Get the command
meaner = fsl.MeanImage(in_file="a.nii", out_file="b.nii")
# Test the underlying command
assert meaner.cmd == "fslmaths"
# Test the defualt opstring
assert meaner.cmdline == "fslmaths a.nii -Tmean b.nii"
# Test the other dimensions
cmdline = "fslmaths a.nii -%smean b.nii"
for dim in ["X", "Y", "Z", "T"]:
meaner.inputs.dimension = dim
assert meaner.cmdline == cmdline % dim
# Test the auto naming
meaner = fsl.MeanImage(in_file="a.nii")
assert meaner.cmdline == "fslmaths a.nii -Tmean %s" % os.path.join(testdir, "a_mean%s" % out_ext)
def COMPOSER(verbose=False, is_bruker=False):
inputnode = Node(IdentityInterface(fields=['in_file', 'ref_file']),
name='input')
outputnode = Node(IdentityInterface(fields=['out_file']), name='output')
wf = Workflow(name='COMPOSER')
in_mag = Node(Complex(magnitude_out_file='in_mag.nii.gz', verbose=verbose),
name='in_magnitude')
ref_mag = Node(Complex(magnitude_out_file='ref_mag.nii.gz',
verbose=verbose),
name='ref_magnitude')
if is_bruker:
wf.connect([(inputnode, in_mag, [('in_file', 'realimag')])])
wf.connect([(inputnode, ref_mag, [('ref_file', 'realimag')])])
else:
wf.connect([(inputnode, in_mag, [('in_file', 'complex')])])
wf.connect([(inputnode, ref_mag, [('ref_file', 'complex')])])
in_mean = Node(maths.MeanImage(), name='in_mean')
ref_mean = Node(maths.MeanImage(), name='ref_mean')
wf.connect([(in_mag, in_mean, [('magnitude_out_file', 'in_file')]),
(ref_mag, ref_mean, [('magnitude_out_file', 'in_file')])])
register = Node(Registration(dimension=3,
initial_moving_transform_com=1,
transforms=['Rigid'],
metric=['Mattes'],
metric_weight=[1],
transform_parameters=[(0.1, )],
number_of_iterations=[[1000, 500, 250]],
collapse_output_transforms=False,
initialize_transforms_per_stage=False,
radius_or_number_of_bins=[32],
sampling_strategy=['Regular', None],
sampling_percentage=[0.25, None],
convergence_threshold=[1.e-6],
smoothing_sigmas=[[4, 2, 1]],
shrink_factors=[[8, 4, 2]],
sigma_units=['vox'],
output_warped_image=True,
verbose=True),
name='register')
wf.connect([(in_mean, register, [('out_file', 'moving_image')]),
(ref_mean, register, [('out_file', 'fixed_image')])])
if is_bruker:
resample = Node(ApplyTransforms(dimension=3, input_image_type=3),
name='resample_reference')
in_x = Node(Complex(complex_out_file='in_x.nii.gz', verbose=verbose),
name='in_x')
ref_x = Node(Complex(complex_out_file='ref_x.nii.gz', verbose=verbose),
name='ref_x')
cc = Node(CoilCombine(), name='cc')
wf.connect([(inputnode, resample, [('ref_file', 'input_image')]),
(in_mean, resample, [('out_file', 'reference_image')]),
(register, resample, [('reverse_transforms', 'transforms')
]),
(inputnode, in_x, [('in_file', 'realimag')]),
(resample, ref_x, [('output_image', 'realimag')]),
(in_x, cc, [('complex_out_file', 'in_file')]),
(ref_x, cc, [('complex_out_file', 'composer_file')]),
(cc, outputnode, [('out_file', 'out_file')])])
else:
raise ('Not Yet Supported')
return wf
def test_meanimage():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
meaner = fsl.MeanImage(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, meaner.cmd, "fslmaths"
# Test the defualt opstring
yield assert_equal, meaner.cmdline, "fslmaths a.nii -Tmean b.nii"
# Test the other dimensions
cmdline = "fslmaths a.nii -%smean b.nii"
for dim in ["X","Y","Z","T"]:
meaner.inputs.dimension=dim
yield assert_equal, meaner.cmdline, cmdline%dim
# Test the auto naming
meaner = fsl.MeanImage(in_file="a.nii")
yield assert_equal, meaner.cmdline, "fslmaths a.nii -Tmean %s"%os.path.join(testdir, "a_mean.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_stdimage():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
stder = fsl.StdImage(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, stder.cmd, "fslmaths"
# Test the defualt opstring
yield assert_equal, stder.cmdline, "fslmaths a.nii -Tstd b.nii"
# Test the other dimensions
cmdline = "fslmaths a.nii -%sstd b.nii"
for dim in ["X","Y","Z","T"]:
stder.inputs.dimension=dim
yield assert_equal, stder.cmdline, cmdline%dim
# Test the auto naming
stder = fsl.StdImage(in_file="a.nii")
yield assert_equal, stder.cmdline, "fslmaths a.nii -Tstd %s"%os.path.join(testdir, "a_std.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_maximage():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
maxer = fsl.MaxImage(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, maxer.cmd, "fslmaths"
# Test the defualt opstring
yield assert_equal, maxer.cmdline, "fslmaths a.nii -Tmax b.nii"
# Test the other dimensions
cmdline = "fslmaths a.nii -%smax b.nii"
for dim in ["X","Y","Z","T"]:
maxer.inputs.dimension=dim
yield assert_equal, maxer.cmdline, cmdline%dim
# Test the auto naming
maxer = fsl.MaxImage(in_file="a.nii")
yield assert_equal, maxer.cmdline, "fslmaths a.nii -Tmax %s"%os.path.join(testdir, "a_max.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_smooth():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
smoother = fsl.IsotropicSmooth(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, smoother.cmd, "fslmaths"
# Test that smoothing kernel is mandatory
yield assert_raises, ValueError, smoother.run
# Test smoothing kernels
cmdline = "fslmaths a.nii -s %.5f b.nii"
for val in [0,1.,1,25,0.5,8/3]:
smoother = fsl.IsotropicSmooth(in_file="a.nii",out_file="b.nii",sigma=val)
yield assert_equal, smoother.cmdline, cmdline%val
smoother = fsl.IsotropicSmooth(in_file="a.nii",out_file="b.nii",fwhm=val)
val = float(val)/np.sqrt(8 * np.log(2))
yield assert_equal, smoother.cmdline, cmdline%val
# Test automatic naming
smoother = fsl.IsotropicSmooth(in_file="a.nii", sigma=5)
yield assert_equal, smoother.cmdline, "fslmaths a.nii -s %.5f %s"%(5, os.path.join(testdir, "a_smooth.nii"))
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_mask():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
masker = fsl.ApplyMask(in_file="a.nii",out_file="c.nii")
# Test the underlying command
yield assert_equal, masker.cmd, "fslmaths"
# Test that the mask image is mandatory
yield assert_raises, ValueError, masker.run
# Test setting the mask image
masker.inputs.mask_file = "b.nii"
yield assert_equal, masker.cmdline, "fslmaths a.nii -mas b.nii c.nii"
# Test auto name generation
masker = fsl.ApplyMask(in_file="a.nii",mask_file="b.nii")
yield assert_equal, masker.cmdline, "fslmaths a.nii -mas b.nii "+os.path.join(testdir, "a_masked.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_dilation():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
diller = fsl.DilateImage(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, diller.cmd, "fslmaths"
# Test that the dilation operation is mandatory
yield assert_raises, ValueError, diller.run
# Test the different dilation operations
for op in ["mean", "modal", "max"]:
cv = dict(mean="M", modal="D", max="F")
diller.inputs.operation = op
yield assert_equal, diller.cmdline, "fslmaths a.nii -dil%s b.nii"%cv[op]
# Now test the different kernel options
for k in ["3D", "2D", "box", "boxv", "gauss", "sphere"]:
for size in [1, 1.5, 5]:
diller.inputs.kernel_shape = k
diller.inputs.kernel_size = size
yield assert_equal, diller.cmdline, "fslmaths a.nii -kernel %s %.4f -dilF b.nii"%(k, size)
# Test that we can use a file kernel
f = open("kernel.txt","w").close()
del f # Shut pyflakes up
diller.inputs.kernel_shape = "file"
diller.inputs.kernel_size = Undefined
diller.inputs.kernel_file = "kernel.txt"
yield assert_equal, diller.cmdline, "fslmaths a.nii -kernel file kernel.txt -dilF b.nii"
# Test that we don't need to request an out name
dil = fsl.DilateImage(in_file="a.nii", operation="max")
yield assert_equal, dil.cmdline, "fslmaths a.nii -dilF %s"%os.path.join(testdir, "a_dil.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_erosion():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
erode = fsl.ErodeImage(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, erode.cmd, "fslmaths"
# Test the basic command line
yield assert_equal, erode.cmdline, "fslmaths a.nii -ero b.nii"
# Test that something else happens when you minimum filter
erode.inputs.minimum_filter = True
yield assert_equal, erode.cmdline, "fslmaths a.nii -eroF b.nii"
# Test that we don't need to request an out name
erode = fsl.ErodeImage(in_file="a.nii")
yield assert_equal, erode.cmdline, "fslmaths a.nii -ero %s"%os.path.join(testdir, "a_ero.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_spatial_filter():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
filter = fsl.SpatialFilter(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, filter.cmd, "fslmaths"
# Test that it fails without an operation
yield assert_raises, ValueError, filter.run
# Test the different operations
for op in ["mean", "meanu", "median"]:
filter.inputs.operation = op
yield assert_equal, filter.cmdline, "fslmaths a.nii -f%s b.nii"%op
# Test that we don't need to ask for an out name
filter = fsl.SpatialFilter(in_file="a.nii", operation="mean")
yield assert_equal, filter.cmdline, "fslmaths a.nii -fmean %s"%os.path.join(testdir, "a_filt.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_unarymaths():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
maths = fsl.UnaryMaths(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, maths.cmd, "fslmaths"
# Test that it fails without an operation
yield assert_raises, ValueError, maths.run
# Test the different operations
ops = ["exp", "log", "sin", "cos", "sqr", "sqrt", "recip", "abs", "bin", "index"]
for op in ops:
maths.inputs.operation = op
yield assert_equal, maths.cmdline, "fslmaths a.nii -%s b.nii"%op
# Test that we don't need to ask for an out file
for op in ops:
maths = fsl.UnaryMaths(in_file="a.nii", operation=op)
yield assert_equal, maths.cmdline, "fslmaths a.nii -%s %s"%(op, os.path.join(testdir, "a_%s.nii"%op))
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_binarymaths():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
maths = fsl.BinaryMaths(in_file="a.nii",out_file="c.nii")
# Test the underlying command
yield assert_equal, maths.cmd, "fslmaths"
# Test that it fails without an operation an
yield assert_raises, ValueError, maths.run
# Test the different operations
ops = ["add", "sub", "mul", "div", "rem", "min", "max"]
operands = ["b.nii", -2, -0.5, 0, .123456, np.pi, 500]
for op in ops:
for ent in operands:
maths = fsl.BinaryMaths(in_file="a.nii", out_file="c.nii", operation = op)
if ent == "b.nii":
maths.inputs.operand_file = ent
yield assert_equal, maths.cmdline, "fslmaths a.nii -%s b.nii c.nii"%op
else:
maths.inputs.operand_value = ent
yield assert_equal, maths.cmdline, "fslmaths a.nii -%s %.8f c.nii"%(op, ent)
# Test that we don't need to ask for an out file
for op in ops:
maths = fsl.BinaryMaths(in_file="a.nii", operation=op, operand_file="b.nii")
yield assert_equal, maths.cmdline, "fslmaths a.nii -%s b.nii %s"%(op,os.path.join(testdir,"a_maths.nii"))
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_multimaths():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
maths = fsl.MultiImageMaths(in_file="a.nii",out_file="c.nii")
# Test the underlying command
yield assert_equal, maths.cmd, "fslmaths"
# Test that it fails without an operation an
yield assert_raises, ValueError, maths.run
# Test a few operations
maths.inputs.operand_files = ["a.nii", "b.nii"]
opstrings = ["-add %s -div %s",
"-max 1 -sub %s -min %s",
"-mas %s -add %s"]
for ostr in opstrings:
maths.inputs.op_string = ostr
yield assert_equal, maths.cmdline, "fslmaths a.nii %s c.nii"%ostr%("a.nii", "b.nii")
# Test that we don't need to ask for an out file
maths = fsl.MultiImageMaths(in_file="a.nii", op_string="-add %s -mul 5", operand_files=["b.nii"])
yield assert_equal, maths.cmdline, \
"fslmaths a.nii -add b.nii -mul 5 %s"%os.path.join(testdir,"a_maths.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
@skipif(no_fsl)
def test_tempfilt():
files, testdir, origdir, ftype = create_files_in_directory()
# Get the command
filt = fsl.TemporalFilter(in_file="a.nii",out_file="b.nii")
# Test the underlying command
yield assert_equal, filt.cmd, "fslmaths"
# Test that both filters are initialized off
yield assert_equal, filt.cmdline, "fslmaths a.nii -bptf -1.000000 -1.000000 b.nii"
# Test some filters
windows = [(-1, -1), (0.1, 0.1), (-1, 20), (20, -1), (128, 248)]
for win in windows:
filt.inputs.highpass_sigma = win[0]
filt.inputs.lowpass_sigma = win[1]
yield assert_equal, filt.cmdline, "fslmaths a.nii -bptf %.6f %.6f b.nii"%win
# Test that we don't need to ask for an out file
filt = fsl.TemporalFilter(in_file="a.nii", highpass_sigma = 64)
yield assert_equal, filt.cmdline, \
"fslmaths a.nii -bptf 64.000000 -1.000000 %s"%os.path.join(testdir,"a_filt.nii")
# Clean up our mess
clean_directory(testdir, origdir, ftype)
