def test_sct_maths_add_images_no_checks():
"""Run the CLI script without checking results.
TODO: Check the results. (This test replaces the 'sct_testing' test, which did not implement any checks.)"""
sct_maths.main(argv=[
'-i', 'mt/mtr.nii.gz', '-add', 'mt/mtr.nii.gz', 'mt/mtr.nii.gz', '-o',
'test.nii.gz'
])
def test_sct_maths_symmetrize(dim, tmp_path):
"""Run the CLI script, then verify that symmetrize properly flips and
averages the image data."""
path_in = sct_test_path('t2', 't2.nii.gz')
path_out = str(tmp_path / f't2_sym_{dim}.nii.gz')
sct_maths.main(
argv=['-i', path_in, '-symmetrize',
str(dim), '-o', path_out])
im_in = Image(path_out)
im_out = Image(path_out)
assert np.array_equal(
im_out.data, (im_in.data + np.flip(im_in.data, axis=int(dim))) / 2.0)
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv if argv else ['--help'])
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# Initialization
param = Param()
start_time = time.time()
fname_anat = arguments.i
fname_centerline = arguments.s
param.algo_fitting = arguments.algo_fitting
if arguments.smooth is not None:
sigma = arguments.smooth
remove_temp_files = arguments.r
# Display arguments
printv('\nCheck input arguments...')
printv(' Volume to smooth .................. ' + fname_anat)
printv(' Centerline ........................ ' + fname_centerline)
printv(' Sigma (mm) ........................ ' + str(sigma))
printv(' Verbose ........................... ' + str(verbose))
# Check that input is 3D:
nx, ny, nz, nt, px, py, pz, pt = Image(fname_anat).dim
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
if dim == 4:
printv(
'WARNING: the input image is 4D, please split your image to 3D before smoothing spinalcord using :\n'
'sct_image -i ' + fname_anat + ' -split t -o ' + fname_anat,
verbose, 'warning')
printv('4D images not supported, aborting ...', verbose, 'error')
# Extract path/file/extension
path_anat, file_anat, ext_anat = extract_fname(fname_anat)
path_centerline, file_centerline, ext_centerline = extract_fname(
fname_centerline)
path_tmp = tmp_create(basename="smooth_spinalcord")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder and convert to nii...', verbose)
copy(fname_anat, os.path.join(path_tmp, "anat" + ext_anat))
copy(fname_centerline, os.path.join(path_tmp,
"centerline" + ext_centerline))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# convert to nii format
convert('anat' + ext_anat, 'anat.nii')
convert('centerline' + ext_centerline, 'centerline.nii')
# Change orientation of the input image into RPI
printv('\nOrient input volume to RPI orientation...')
fname_anat_rpi = Image("anat.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Change orientation of the input image into RPI
printv('\nOrient centerline to RPI orientation...')
fname_centerline_rpi = Image("centerline.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Straighten the spinal cord
# straighten segmentation
printv('\nStraighten the spinal cord using centerline/segmentation...',
verbose)
cache_sig = cache_signature(
input_files=[fname_anat_rpi, fname_centerline_rpi],
input_params={"x": "spline"})
cachefile = os.path.join(curdir, "straightening.cache")
if cache_valid(cachefile, cache_sig) and os.path.isfile(
os.path.join(
curdir, 'warp_curve2straight.nii.gz')) and os.path.isfile(
os.path.join(
curdir,
'warp_straight2curve.nii.gz')) and os.path.isfile(
os.path.join(curdir, 'straight_ref.nii.gz')):
# if they exist, copy them into current folder
printv('Reusing existing warping field which seems to be valid',
verbose, 'warning')
copy(os.path.join(curdir, 'warp_curve2straight.nii.gz'),
'warp_curve2straight.nii.gz')
copy(os.path.join(curdir, 'warp_straight2curve.nii.gz'),
'warp_straight2curve.nii.gz')
copy(os.path.join(curdir, 'straight_ref.nii.gz'),
'straight_ref.nii.gz')
# apply straightening
run_proc([
'sct_apply_transfo', '-i', fname_anat_rpi, '-w',
'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o',
'anat_rpi_straight.nii', '-x', 'spline'
], verbose)
else:
run_proc([
'sct_straighten_spinalcord', '-i', fname_anat_rpi, '-o',
'anat_rpi_straight.nii', '-s', fname_centerline_rpi, '-x',
'spline', '-param', 'algo_fitting=' + param.algo_fitting
], verbose)
cache_save(cachefile, cache_sig)
# move warping fields locally (to use caching next time)
copy('warp_curve2straight.nii.gz',
os.path.join(curdir, 'warp_curve2straight.nii.gz'))
copy('warp_straight2curve.nii.gz',
os.path.join(curdir, 'warp_straight2curve.nii.gz'))
# Smooth the straightened image along z
printv('\nSmooth the straightened image...')
sigma_smooth = ",".join([str(i) for i in sigma])
sct_maths.main(argv=[
'-i', 'anat_rpi_straight.nii', '-smooth', sigma_smooth, '-o',
'anat_rpi_straight_smooth.nii', '-v', '0'
])
# Apply the reversed warping field to get back the curved spinal cord
printv(
'\nApply the reversed warping field to get back the curved spinal cord...'
)
run_proc([
'sct_apply_transfo', '-i', 'anat_rpi_straight_smooth.nii', '-o',
'anat_rpi_straight_smooth_curved.nii', '-d', 'anat.nii', '-w',
'warp_straight2curve.nii.gz', '-x', 'spline'
], verbose)
# replace zeroed voxels by original image (issue #937)
printv('\nReplace zeroed voxels by original image...', verbose)
nii_smooth = Image('anat_rpi_straight_smooth_curved.nii')
data_smooth = nii_smooth.data
data_input = Image('anat.nii').data
indzero = np.where(data_smooth == 0)
data_smooth[indzero] = data_input[indzero]
nii_smooth.data = data_smooth
nii_smooth.save('anat_rpi_straight_smooth_curved_nonzero.nii')
# come back
os.chdir(curdir)
# Generate output file
printv('\nGenerate output file...')
generate_output_file(
os.path.join(path_tmp, "anat_rpi_straight_smooth_curved_nonzero.nii"),
file_anat + '_smooth' + ext_anat)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...')
rmtree(path_tmp)
# Display elapsed time
elapsed_time = time.time() - start_time
printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) +
's\n')
display_viewer_syntax([file_anat, file_anat + '_smooth'], verbose=verbose)
def merge_images(list_fname_src, fname_dest, list_fname_warp, param):
"""
Merge multiple source images onto destination space. All images are warped to the destination space and then added.
To deal with overlap during merging (e.g. one voxel in destination image is shared with two input images), the
resulting voxel is divided by the sum of the partial volume of each image. For example, if src(x,y,z)=1 is mapped to
dest(i,j,k) with a partial volume of 0.5 (because destination voxel is bigger), then its value after linear interpolation
will be 0.5. To account for partial volume, the resulting voxel will be: dest(i,j,k) = 0.5*0.5/0.5 = 0.5.
Now, if two voxels overlap in the destination space, let's say: src(x,y,z)=1 and src2'(x',y',z')=1, then the
resulting value will be: dest(i,j,k) = (0.5*0.5 + 0.5*0.5) / (0.5+0.5) = 0.5. So this function acts like a weighted
average operator, only in destination voxels that share multiple source voxels.
Parameters
----------
list_fname_src
fname_dest
list_fname_warp
param
Returns
-------
"""
# create temporary folder
path_tmp = tmp_create()
# get dimensions of destination file
nii_dest = Image(fname_dest)
# initialize variables
data = np.zeros([nii_dest.dim[0], nii_dest.dim[1], nii_dest.dim[2], len(list_fname_src)])
partial_volume = np.zeros([nii_dest.dim[0], nii_dest.dim[1], nii_dest.dim[2], len(list_fname_src)])
data_merge = np.zeros([nii_dest.dim[0], nii_dest.dim[1], nii_dest.dim[2]])
# loop across files
i_file = 0
for fname_src in list_fname_src:
# apply transformation src --> dest
sct_apply_transfo.main(argv=[
'-i', fname_src,
'-d', fname_dest,
'-w', list_fname_warp[i_file],
'-x', param.interp,
'-o', 'src_' + str(i_file) + '_template.nii.gz',
'-v', str(param.verbose)])
# create binary mask from input file by assigning one to all non-null voxels
sct_maths.main(argv=[
'-i', fname_src,
'-bin', str(param.almost_zero),
'-o', 'src_' + str(i_file) + 'native_bin.nii.gz'])
# apply transformation to binary mask to compute partial volume
sct_apply_transfo.main(argv=[
'-i', 'src_' + str(i_file) + 'native_bin.nii.gz',
'-d', fname_dest,
'-w', list_fname_warp[i_file],
'-x', param.interp,
'-o', 'src_' + str(i_file) + '_template_partialVolume.nii.gz'])
# open data
data[:, :, :, i_file] = Image('src_' + str(i_file) + '_template.nii.gz').data
partial_volume[:, :, :, i_file] = Image('src_' + str(i_file) + '_template_partialVolume.nii.gz').data
i_file += 1
# merge files using partial volume information (and convert nan resulting from division by zero to zeros)
data_merge = np.divide(np.sum(data * partial_volume, axis=3), np.sum(partial_volume, axis=3))
data_merge = np.nan_to_num(data_merge)
# write result in file
nii_dest.data = data_merge
nii_dest.save(param.fname_out)
# remove temporary folder
if param.rm_tmp:
rmtree(path_tmp)