def convert(fname_in, fname_out, squeeze_data=True, dtype=None, verbose=1):
"""
Convert data
:return True/False
"""
printv('sct_convert -i ' + fname_in + ' -o ' + fname_out, verbose, 'code')
img = image.Image(fname_in)
img = image.convert(img, squeeze_data=squeeze_data, dtype=dtype)
img.save(fname_out, mutable=True, verbose=verbose)
def main(argv=None):
"""
Main function
:param args:
:return:
"""
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# Building the command, do sanity checks
fname_in = arguments.i
fname_out = arguments.o
squeeze_data = bool(arguments.squeeze)
# convert file
img = image.Image(fname_in)
img = image.convert(img, squeeze_data=squeeze_data)
img.save(fname_out, mutable=True, verbose=verbose)
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
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:
sigmas = arguments.smooth
remove_temp_files = arguments.r
if arguments.o is not None:
fname_out = arguments.o
else:
fname_out = extract_fname(fname_anat)[1] + '_smooth.nii'
# Display arguments
printv('\nCheck input arguments...')
printv(' Volume to smooth .................. ' + fname_anat)
printv(' Centerline ........................ ' + fname_centerline)
printv(' Sigma (mm) ........................ ' + str(sigmas))
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
im_anat = convert(Image('anat' + ext_anat))
im_anat.save('anat.nii', mutable=True, verbose=verbose)
im_centerline = convert(Image('centerline' + ext_centerline))
im_centerline.save('centerline.nii', mutable=True, verbose=verbose)
# Change orientation of the input image into RPI
printv('\nOrient input volume to RPI orientation...')
img_anat_rpi = Image("anat.nii").change_orientation("RPI")
fname_anat_rpi = add_suffix(img_anat_rpi.absolutepath, "_rpi")
img_anat_rpi.save(path=fname_anat_rpi, mutable=True)
# Change orientation of the input image into RPI
printv('\nOrient centerline to RPI orientation...')
img_centerline_rpi = Image("centerline.nii").change_orientation("RPI")
fname_centerline_rpi = add_suffix(img_centerline_rpi.absolutepath, "_rpi")
img_centerline_rpi.save(path=fname_centerline_rpi, mutable=True)
# 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...')
img = Image("anat_rpi_straight.nii")
out = img.copy()
if len(sigmas) == 1:
sigmas = [sigmas[0] for i in range(len(img.data.shape))]
elif len(sigmas) != len(img.data.shape):
raise ValueError(
"-smooth need the same number of inputs as the number of image dimension OR only one input"
)
sigmas = [sigmas[i] / img.dim[i + 4] for i in range(3)]
out.data = smooth(out.data, sigmas)
out.save(path="anat_rpi_straight_smooth.nii")
# 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"),
fname_out)
# 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([fname_anat, fname_out], verbose=verbose)
def check_and_correct_segmentation(fname_segmentation,
fname_centerline,
folder_output='',
threshold_distance=5.0,
remove_temp_files=1,
verbose=0):
"""
This function takes the outputs of isct_propseg (centerline and segmentation) and check if the centerline of the
segmentation is coherent with the centerline provided by the isct_propseg, especially on the edges (related
to issue #1074).
Args:
fname_segmentation: filename of binary segmentation
fname_centerline: filename of binary centerline
threshold_distance: threshold, in mm, beyond which centerlines are not coherent
verbose:
Returns: None
"""
printv('\nCheck consistency of segmentation...', verbose)
# creating a temporary folder in which all temporary files will be placed and deleted afterwards
path_tmp = tmp_create(basename="propseg")
im_seg = convert(Image(fname_segmentation))
im_seg.save(os.path.join(path_tmp, "tmp.segmentation.nii.gz"),
mutable=True,
verbose=0)
im_centerline = convert(Image(fname_centerline))
im_centerline.save(os.path.join(path_tmp, "tmp.centerline.nii.gz"),
mutable=True,
verbose=0)
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# convert input to RPI (and store original info to use when converting back at the end)
fname_seg_absolute = os.path.abspath(fname_segmentation)
image_input_orientation = im_seg.orientation
sct_image.main(
"-i tmp.segmentation.nii.gz -setorient RPI -o tmp.segmentation_RPI.nii.gz -v 0"
.split())
sct_image.main(
"-i tmp.centerline.nii.gz -setorient RPI -o tmp.centerline_RPI.nii.gz -v 0"
.split())
# go through segmentation image, and compare with centerline from propseg
im_seg = Image('tmp.segmentation_RPI.nii.gz')
im_centerline = Image('tmp.centerline_RPI.nii.gz')
# Get size of data
printv('\nGet data dimensions...', verbose)
nx, ny, nz, nt, px, py, pz, pt = im_seg.dim
# extraction of centerline provided by isct_propseg and computation of center of mass for each slice
# the centerline is defined as the center of the tubular mesh outputed by propseg.
centerline, key_centerline = {}, []
for i in range(nz):
slice = im_centerline.data[:, :, i]
if np.any(slice):
x_centerline, y_centerline = ndi.measurements.center_of_mass(slice)
centerline[str(i)] = [x_centerline, y_centerline]
key_centerline.append(i)
minz_centerline = np.min(key_centerline)
maxz_centerline = np.max(key_centerline)
mid_slice = int((maxz_centerline - minz_centerline) / 2)
# for each slice of the segmentation, check if only one object is present. If not, remove the slice from segmentation.
# If only one object (the spinal cord) is present in the slice, check if its center of mass is close to the centerline of isct_propseg.
slices_to_remove = [
False
] * nz # flag that decides if the slice must be removed
for i in range(minz_centerline, maxz_centerline + 1):
# extraction of slice
slice = im_seg.data[:, :, i]
distance = -1
label_objects, nb_labels = ndi.label(
slice) # count binary objects in the slice
if nb_labels > 1: # if there is more that one object in the slice, the slice is removed from the segmentation
slices_to_remove[i] = True
elif nb_labels == 1: # check if the centerline is coherent with the one from isct_propseg
x_centerline, y_centerline = ndi.measurements.center_of_mass(slice)
slice_nearest_coord = min(key_centerline, key=lambda x: abs(x - i))
coord_nearest_coord = centerline[str(slice_nearest_coord)]
distance = np.sqrt((
(x_centerline - coord_nearest_coord[0]) * px)**2 + (
(y_centerline - coord_nearest_coord[1]) * py)**2 +
((i - slice_nearest_coord) * pz)**2)
if distance >= threshold_distance: # threshold must be adjusted, default is 5 mm
slices_to_remove[i] = True
# Check list of removal and keep one continuous centerline (improve this comment)
# Method:
# starting from mid-centerline (in both directions), the first True encountered is applied to all following slices
slice_to_change = False
for i in range(mid_slice, nz):
if slice_to_change:
slices_to_remove[i] = True
elif slices_to_remove[i]:
slice_to_change = True
slice_to_change = False
for i in range(mid_slice, 0, -1):
if slice_to_change:
slices_to_remove[i] = True
elif slices_to_remove[i]:
slice_to_change = True
for i in range(0, nz):
# remove the slice
if slices_to_remove[i]:
im_seg.data[:, :, i] *= 0
# saving the image
im_seg.save('tmp.segmentation_RPI_c.nii.gz')
# replacing old segmentation with the corrected one
sct_image.main(
'-i tmp.segmentation_RPI_c.nii.gz -setorient {} -o {} -v 0'.format(
image_input_orientation, fname_seg_absolute).split())
os.chdir(curdir)
# display information about how much of the segmentation has been corrected
# remove temporary files
if remove_temp_files:
# printv("\nRemove temporary files...", verbose)
rmtree(path_tmp)
def moco(param):
"""
Main function that performs motion correction.
:param param:
:return:
"""
# retrieve parameters
file_data = param.file_data
file_target = param.file_target
folder_mat = param.mat_moco # output folder of mat file
todo = param.todo
suffix = param.suffix
verbose = param.verbose
# other parameters
file_mask = 'mask.nii'
printv('\nInput parameters:', param.verbose)
printv(' Input file ............ ' + file_data, param.verbose)
printv(' Reference file ........ ' + file_target, param.verbose)
printv(' Polynomial degree ..... ' + param.poly, param.verbose)
printv(' Smoothing kernel ...... ' + param.smooth, param.verbose)
printv(' Gradient step ......... ' + param.gradStep, param.verbose)
printv(' Metric ................ ' + param.metric, param.verbose)
printv(' Sampling .............. ' + param.sampling, param.verbose)
printv(' Todo .................. ' + todo, param.verbose)
printv(' Mask ................. ' + param.fname_mask, param.verbose)
printv(' Output mat folder ..... ' + folder_mat, param.verbose)
try:
os.makedirs(folder_mat)
except FileExistsError:
pass
# Get size of data
printv('\nData dimensions:', verbose)
im_data = Image(param.file_data)
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
printv(
(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' + str(nt)),
verbose)
# copy file_target to a temporary file
printv('\nCopy file_target to a temporary file...', verbose)
im_target = convert(Image(param.file_target))
im_target.save("target.nii.gz", mutable=True, verbose=0)
# Check if user specified a mask
if not param.fname_mask == '':
# Check if this mask is soft (i.e., non-binary, such as a Gaussian mask)
im_mask = Image(param.fname_mask)
if not np.array_equal(im_mask.data, im_mask.data.astype(bool)):
# If it is a soft mask, multiply the target by the soft mask.
im = Image(file_target)
im_masked = im.copy()
im_masked.data = im.data * im_mask.data
im_masked.save(
verbose=0) # silence warning about file overwritting
# If scan is sagittal, split src and target along Z (slice)
if param.is_sagittal:
dim_sag = 2 # TODO: find it
# z-split data (time series)
im_z_list = split_data(im_data, dim=dim_sag, squeeze_data=False)
file_data_splitZ = []
for im_z in im_z_list:
im_z.save(verbose=0)
file_data_splitZ.append(im_z.absolutepath)
# z-split target
im_targetz_list = split_data(Image(file_target),
dim=dim_sag,
squeeze_data=False)
file_target_splitZ = []
for im_targetz in im_targetz_list:
im_targetz.save(verbose=0)
file_target_splitZ.append(im_targetz.absolutepath)
# z-split mask (if exists)
if not param.fname_mask == '':
im_maskz_list = split_data(Image(file_mask),
dim=dim_sag,
squeeze_data=False)
file_mask_splitZ = []
for im_maskz in im_maskz_list:
im_maskz.save(verbose=0)
file_mask_splitZ.append(im_maskz.absolutepath)
# initialize file list for output matrices
file_mat = np.empty((nz, nt), dtype=object)
# axial orientation
else:
file_data_splitZ = [file_data] # TODO: make it absolute like above
file_target_splitZ = [file_target] # TODO: make it absolute like above
# initialize file list for output matrices
file_mat = np.empty((1, nt), dtype=object)
# deal with mask
if not param.fname_mask == '':
im_mask = convert(Image(param.fname_mask), squeeze_data=False)
im_mask.save(file_mask, mutable=True, verbose=0)
im_maskz_list = [Image(file_mask)
] # use a list with single element
# Loop across file list, where each file is either a 2D volume (if sagittal) or a 3D volume (otherwise)
# file_mat = tuple([[[] for i in range(nt)] for i in range(nz)])
file_data_splitZ_moco = []
printv(
'\nRegister. Loop across Z (note: there is only one Z if orientation is axial)'
)
for file in file_data_splitZ:
iz = file_data_splitZ.index(file)
# Split data along T dimension
# printv('\nSplit data along T dimension.', verbose)
im_z = Image(file)
list_im_zt = split_data(im_z, dim=3)
file_data_splitZ_splitT = []
for im_zt in list_im_zt:
im_zt.save(verbose=0)
file_data_splitZ_splitT.append(im_zt.absolutepath)
# file_data_splitT = file_data + '_T'
# Motion correction: initialization
index = np.arange(nt)
file_data_splitT_num = []
file_data_splitZ_splitT_moco = []
failed_transfo = [0 for i in range(nt)]
# Motion correction: Loop across T
for indice_index in sct_progress_bar(range(nt),
unit='iter',
unit_scale=False,
desc="Z=" + str(iz) + "/" +
str(len(file_data_splitZ) - 1),
ascii=False,
ncols=80):
# create indices and display stuff
it = index[indice_index]
file_mat[iz][it] = os.path.join(
folder_mat,
"mat.Z") + str(iz).zfill(4) + 'T' + str(it).zfill(4)
file_data_splitZ_splitT_moco.append(
add_suffix(file_data_splitZ_splitT[it], '_moco'))
# deal with masking (except in the 'apply' case, where masking is irrelevant)
input_mask = None
if not param.fname_mask == '' and not param.todo == 'apply':
# Check if mask is binary
if np.array_equal(im_maskz_list[iz].data,
im_maskz_list[iz].data.astype(bool)):
# If it is, pass this mask into register() to be used
input_mask = im_maskz_list[iz]
else:
# If not, do not pass this mask into register() because ANTs cannot handle non-binary masks.
# Instead, multiply the input data by the Gaussian mask.
im = Image(file_data_splitZ_splitT[it])
im_masked = im.copy()
im_masked.data = im.data * im_maskz_list[iz].data
im_masked.save(
verbose=0) # silence warning about file overwritting
# run 3D registration
failed_transfo[it] = register(param,
file_data_splitZ_splitT[it],
file_target_splitZ[iz],
file_mat[iz][it],
file_data_splitZ_splitT_moco[it],
im_mask=input_mask)
# average registered volume with target image
# N.B. use weighted averaging: (target * nb_it + moco) / (nb_it + 1)
if param.iterAvg and indice_index < 10 and failed_transfo[
it] == 0 and not param.todo == 'apply':
im_targetz = Image(file_target_splitZ[iz])
data_targetz = im_targetz.data
data_mocoz = Image(file_data_splitZ_splitT_moco[it]).data
data_targetz = (data_targetz * (indice_index + 1) +
data_mocoz) / (indice_index + 2)
im_targetz.data = data_targetz
im_targetz.save(verbose=0)
# Replace failed transformation with the closest good one
fT = [i for i, j in enumerate(failed_transfo) if j == 1]
gT = [i for i, j in enumerate(failed_transfo) if j == 0]
for it in range(len(fT)):
abs_dist = [np.abs(gT[i] - fT[it]) for i in range(len(gT))]
if not abs_dist == []:
index_good = abs_dist.index(min(abs_dist))
printv(
' transfo #' + str(fT[it]) + ' --> use transfo #' +
str(gT[index_good]), verbose)
# copy transformation
copy(file_mat[iz][gT[index_good]] + 'Warp.nii.gz',
file_mat[iz][fT[it]] + 'Warp.nii.gz')
# apply transformation
sct_apply_transfo.main(argv=[
'-i', file_data_splitZ_splitT[fT[it]], '-d', file_target,
'-w', file_mat[iz][fT[it]] + 'Warp.nii.gz', '-o',
file_data_splitZ_splitT_moco[fT[it]], '-x', param.interp
])
else:
# exit program if no transformation exists.
printv(
'\nERROR in ' + os.path.basename(__file__) +
': No good transformation exist. Exit program.\n', verbose,
'error')
sys.exit(2)
# Merge data along T
file_data_splitZ_moco.append(add_suffix(file, suffix))
if todo != 'estimate':
im_data_splitZ_splitT_moco = [
Image(fname) for fname in file_data_splitZ_splitT_moco
]
im_out = concat_data(im_data_splitZ_splitT_moco, 3)
im_out.absolutepath = file_data_splitZ_moco[iz]
im_out.save(verbose=0)
# If sagittal, merge along Z
if param.is_sagittal:
# TODO: im_out.dim is incorrect: Z value is one
im_data_splitZ_moco = [Image(fname) for fname in file_data_splitZ_moco]
im_out = concat_data(im_data_splitZ_moco, 2)
dirname, basename, ext = extract_fname(file_data)
path_out = os.path.join(dirname, basename + suffix + ext)
im_out.absolutepath = path_out
im_out.save(verbose=0)
return file_mat, im_out
def moco_wrapper(param):
"""
Wrapper that performs motion correction.
:param param: ParamMoco class
:return: fname_moco
"""
file_data = 'data.nii' # corresponds to the full input data (e.g. dmri or fmri)
file_data_dirname, file_data_basename, file_data_ext = extract_fname(
file_data)
file_b0 = 'b0.nii'
file_datasub = 'datasub.nii' # corresponds to the full input data minus the b=0 scans (if param.is_diffusion=True)
file_datasubgroup = 'datasub-groups.nii' # concatenation of the average of each file_datasub
file_mask = 'mask.nii'
file_moco_params_csv = 'moco_params.tsv'
file_moco_params_x = 'moco_params_x.nii.gz'
file_moco_params_y = 'moco_params_y.nii.gz'
ext_data = '.nii.gz' # workaround "too many open files" by slurping the data
# TODO: check if .nii can be used
mat_final = 'mat_final/'
# ext_mat = 'Warp.nii.gz' # warping field
# Start timer
start_time = time.time()
printv('\nInput parameters:', param.verbose)
printv(' Input file ............ ' + param.fname_data, param.verbose)
printv(' Group size ............ {}'.format(param.group_size),
param.verbose)
path_tmp = tmp_create(basename="moco")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder and convert to nii...',
param.verbose)
im_data = convert(Image(param.fname_data))
im_data.save(os.path.join(path_tmp, file_data),
mutable=True,
verbose=param.verbose)
if param.fname_mask != '':
im_mask = convert(Image(param.fname_mask))
im_mask.save(os.path.join(path_tmp, file_mask),
mutable=True,
verbose=param.verbose)
# Update field in param (because used later in another function, and param class will be passed)
param.fname_mask = file_mask
if param.fname_bvals != '':
_, _, ext_bvals = extract_fname(param.fname_bvals)
file_bvals = f"bvals.{ext_bvals}" # Use hardcoded name to avoid potential duplicate files when copying
copyfile(param.fname_bvals, os.path.join(path_tmp, file_bvals))
param.fname_bvals = file_bvals
if param.fname_bvecs != '':
_, _, ext_bvecs = extract_fname(param.fname_bvecs)
file_bvecs = f"bvecs.{ext_bvecs}" # Use hardcoded name to avoid potential duplicate files when copying
copyfile(param.fname_bvecs, os.path.join(path_tmp, file_bvecs))
param.fname_bvecs = file_bvecs
# Build absolute output path and go to tmp folder
curdir = os.getcwd()
path_out_abs = os.path.abspath(param.path_out)
os.chdir(path_tmp)
# Get dimensions of data
printv('\nGet dimensions of data...', param.verbose)
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
printv(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz), param.verbose)
# Get orientation
printv('\nData orientation: ' + im_data.orientation, param.verbose)
if im_data.orientation[2] in 'LR':
param.is_sagittal = True
printv(' Treated as sagittal')
elif im_data.orientation[2] in 'IS':
param.is_sagittal = False
printv(' Treated as axial')
else:
param.is_sagittal = False
printv(
'WARNING: Orientation seems to be neither axial nor sagittal. Treated as axial.'
)
printv(
"\nSet suffix of transformation file name, which depends on the orientation:"
)
if param.is_sagittal:
param.suffix_mat = '0GenericAffine.mat'
printv(
"Orientation is sagittal, suffix is '{}'. The image is split across the R-L direction, and the "
"estimated transformation is a 2D affine transfo.".format(
param.suffix_mat))
else:
param.suffix_mat = 'Warp.nii.gz'
printv(
"Orientation is axial, suffix is '{}'. The estimated transformation is a 3D warping field, which is "
"composed of a stack of 2D Tx-Ty transformations".format(
param.suffix_mat))
# Adjust group size in case of sagittal scan
if param.is_sagittal and param.group_size != 1:
printv(
'For sagittal data group_size should be one for more robustness. Forcing group_size=1.',
1, 'warning')
param.group_size = 1
if param.is_diffusion:
# Identify b=0 and DWI images
index_b0, index_dwi, nb_b0, nb_dwi = \
sct_dmri_separate_b0_and_dwi.identify_b0(param.fname_bvecs, param.fname_bvals, param.bval_min,
param.verbose)
# check if dmri and bvecs are the same size
if not nb_b0 + nb_dwi == nt:
printv(
'\nERROR in ' + os.path.basename(__file__) +
': Size of data (' + str(nt) + ') and size of bvecs (' +
str(nb_b0 + nb_dwi) +
') are not the same. Check your bvecs file.\n', 1, 'error')
sys.exit(2)
# ==================================================================================================================
# Prepare data (mean/groups...)
# ==================================================================================================================
# Split into T dimension
printv('\nSplit along T dimension...', param.verbose)
im_data_split_list = split_data(im_data, 3)
for im in im_data_split_list:
x_dirname, x_basename, x_ext = extract_fname(im.absolutepath)
im.absolutepath = os.path.join(x_dirname, x_basename + ".nii.gz")
im.save()
if param.is_diffusion:
# Merge and average b=0 images
printv('\nMerge and average b=0 data...', param.verbose)
im_b0_list = []
for it in range(nb_b0):
im_b0_list.append(im_data_split_list[index_b0[it]])
im_b0 = concat_data(im_b0_list, 3).save(file_b0, verbose=0)
# Average across time
im_b0.mean(dim=3).save(add_suffix(file_b0, '_mean'))
n_moco = nb_dwi # set number of data to perform moco on (using grouping)
index_moco = index_dwi
# If not a diffusion scan, we will motion-correct all volumes
else:
n_moco = nt
index_moco = list(range(0, nt))
nb_groups = int(math.floor(n_moco / param.group_size))
# Generate groups indexes
group_indexes = []
for iGroup in range(nb_groups):
group_indexes.append(index_moco[(iGroup *
param.group_size):((iGroup + 1) *
param.group_size)])
# add the remaining images to a new last group (in case the total number of image is not divisible by group_size)
nb_remaining = n_moco % param.group_size # number of remaining images
if nb_remaining > 0:
nb_groups += 1
group_indexes.append(index_moco[len(index_moco) -
nb_remaining:len(index_moco)])
_, file_dwi_basename, file_dwi_ext = extract_fname(file_datasub)
# Group data
list_file_group = []
for iGroup in sct_progress_bar(range(nb_groups),
unit='iter',
unit_scale=False,
desc="Merge within groups",
ascii=False,
ncols=80):
# get index
index_moco_i = group_indexes[iGroup]
n_moco_i = len(index_moco_i)
# concatenate images across time, within this group
file_dwi_merge_i = os.path.join(file_dwi_basename + '_' + str(iGroup) +
ext_data)
im_dwi_list = []
for it in range(n_moco_i):
im_dwi_list.append(im_data_split_list[index_moco_i[it]])
im_dwi_out = concat_data(im_dwi_list, 3).save(file_dwi_merge_i,
verbose=0)
# Average across time
list_file_group.append(
os.path.join(file_dwi_basename + '_' + str(iGroup) + '_mean' +
ext_data))
im_dwi_out.mean(dim=3).save(list_file_group[-1])
# Merge across groups
printv('\nMerge across groups...', param.verbose)
# file_dwi_groups_means_merge = 'dwi_averaged_groups'
fname_dw_list = []
for iGroup in range(nb_groups):
fname_dw_list.append(list_file_group[iGroup])
im_dw_list = [Image(fname) for fname in fname_dw_list]
concat_data(im_dw_list, 3).save(file_datasubgroup, verbose=0)
# Cleanup
del im, im_data_split_list
# ==================================================================================================================
# Estimate moco
# ==================================================================================================================
# Initialize another class instance that will be passed on to the moco() function
param_moco = deepcopy(param)
if param.is_diffusion:
# Estimate moco on b0 groups
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Estimating motion on b=0 images...', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = 'b0.nii'
# Identify target image
if index_moco[0] != 0:
# If first DWI is not the first volume (most common), then there is a least one b=0 image before. In that
# case select it as the target image for registration of all b=0
param_moco.file_target = os.path.join(
file_data_dirname, file_data_basename + '_T' +
str(index_b0[index_moco[0] - 1]).zfill(4) + ext_data)
else:
# If first DWI is the first volume, then the target b=0 is the first b=0 from the index_b0.
param_moco.file_target = os.path.join(
file_data_dirname, file_data_basename + '_T' +
str(index_b0[0]).zfill(4) + ext_data)
# Run moco
param_moco.path_out = ''
param_moco.todo = 'estimate_and_apply'
param_moco.mat_moco = 'mat_b0groups'
file_mat_b0, _ = moco(param_moco)
# Estimate moco across groups
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Estimating motion across groups...', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = file_datasubgroup
param_moco.file_target = list_file_group[
0] # target is the first volume (closest to the first b=0 if DWI scan)
param_moco.path_out = ''
param_moco.todo = 'estimate_and_apply'
param_moco.mat_moco = 'mat_groups'
file_mat_datasub_group, _ = moco(param_moco)
# Spline Regularization along T
if param.spline_fitting:
# TODO: fix this scenario (haven't touched that code for a while-- it is probably buggy)
raise NotImplementedError()
# spline(mat_final, nt, nz, param.verbose, np.array(index_b0), param.plot_graph)
# ==================================================================================================================
# Apply moco
# ==================================================================================================================
# If group_size>1, assign transformation to each individual ungrouped 3d volume
if param.group_size > 1:
file_mat_datasub = []
for iz in range(len(file_mat_datasub_group)):
# duplicate by factor group_size the transformation file for each it
# example: [mat.Z0000T0001Warp.nii] --> [mat.Z0000T0001Warp.nii, mat.Z0000T0001Warp.nii] for group_size=2
file_mat_datasub.append(
functools.reduce(operator.iconcat,
[[i] * param.group_size
for i in file_mat_datasub_group[iz]], []))
else:
file_mat_datasub = file_mat_datasub_group
# Copy transformations to mat_final folder and rename them appropriately
copy_mat_files(nt, file_mat_datasub, index_moco, mat_final, param)
if param.is_diffusion:
copy_mat_files(nt, file_mat_b0, index_b0, mat_final, param)
# Apply moco on all dmri data
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Apply moco', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = file_data
param_moco.file_target = list_file_group[
0] # reference for reslicing into proper coordinate system
param_moco.path_out = '' # TODO not used in moco()
param_moco.mat_moco = mat_final
param_moco.todo = 'apply'
file_mat_data, im_moco = moco(param_moco)
# copy geometric information from header
# NB: this is required because WarpImageMultiTransform in 2D mode wrongly sets pixdim(3) to "1".
im_moco.header = im_data.header
im_moco.save(verbose=0)
# Average across time
if param.is_diffusion:
# generate b0_moco_mean and dwi_moco_mean
args = [
'-i', im_moco.absolutepath, '-bvec', param.fname_bvecs, '-a', '1',
'-v', '0'
]
if not param.fname_bvals == '':
# if bvals file is provided
args += ['-bval', param.fname_bvals]
fname_b0, fname_b0_mean, fname_dwi, fname_dwi_mean = sct_dmri_separate_b0_and_dwi.main(
argv=args)
else:
fname_moco_mean = add_suffix(im_moco.absolutepath, '_mean')
im_moco.mean(dim=3).save(fname_moco_mean)
# Extract and output the motion parameters (doesn't work for sagittal orientation)
printv('Extract motion parameters...')
if param.output_motion_param:
if param.is_sagittal:
printv(
'Motion parameters cannot be generated for sagittal images.',
1, 'warning')
else:
files_warp_X, files_warp_Y = [], []
moco_param = []
for fname_warp in file_mat_data[0]:
# Cropping the image to keep only one voxel in the XY plane
im_warp = Image(fname_warp + param.suffix_mat)
im_warp.data = np.expand_dims(np.expand_dims(
im_warp.data[0, 0, :, :, :], axis=0),
axis=0)
# These three lines allow to generate one file instead of two, containing X, Y and Z moco parameters
#fname_warp_crop = fname_warp + '_crop_' + ext_mat
# files_warp.append(fname_warp_crop)
# im_warp.save(fname_warp_crop)
# Separating the three components and saving X and Y only (Z is equal to 0 by default).
im_warp_XYZ = multicomponent_split(im_warp)
fname_warp_crop_X = fname_warp + '_crop_X_' + param.suffix_mat
im_warp_XYZ[0].save(fname_warp_crop_X)
files_warp_X.append(fname_warp_crop_X)
fname_warp_crop_Y = fname_warp + '_crop_Y_' + param.suffix_mat
im_warp_XYZ[1].save(fname_warp_crop_Y)
files_warp_Y.append(fname_warp_crop_Y)
# Calculating the slice-wise average moco estimate to provide a QC file
moco_param.append([
np.mean(np.ravel(im_warp_XYZ[0].data)),
np.mean(np.ravel(im_warp_XYZ[1].data))
])
# These two lines allow to generate one file instead of two, containing X, Y and Z moco parameters
# im_warp = [Image(fname) for fname in files_warp]
# im_warp_concat = concat_data(im_warp, dim=3)
# im_warp_concat.save('fmri_moco_params.nii')
# Concatenating the moco parameters into a time series for X and Y components.
im_warp_X = [Image(fname) for fname in files_warp_X]
im_warp_concat = concat_data(im_warp_X, dim=3)
im_warp_concat.save(file_moco_params_x)
im_warp_Y = [Image(fname) for fname in files_warp_Y]
im_warp_concat = concat_data(im_warp_Y, dim=3)
im_warp_concat.save(file_moco_params_y)
# Writing a TSV file with the slicewise average estimate of the moco parameters. Useful for QC
with open(file_moco_params_csv, 'wt') as out_file:
tsv_writer = csv.writer(out_file, delimiter='\t')
tsv_writer.writerow(['X', 'Y'])
for mocop in moco_param:
tsv_writer.writerow([mocop[0], mocop[1]])
# Generate output files
printv('\nGenerate output files...', param.verbose)
fname_moco = os.path.join(
path_out_abs,
add_suffix(os.path.basename(param.fname_data), param.suffix))
generate_output_file(im_moco.absolutepath, fname_moco)
if param.is_diffusion:
generate_output_file(fname_b0_mean, add_suffix(fname_moco, '_b0_mean'))
generate_output_file(fname_dwi_mean,
add_suffix(fname_moco, '_dwi_mean'))
else:
generate_output_file(fname_moco_mean, add_suffix(fname_moco, '_mean'))
if os.path.exists(file_moco_params_csv):
generate_output_file(file_moco_params_x,
os.path.join(path_out_abs, file_moco_params_x),
squeeze_data=False)
generate_output_file(file_moco_params_y,
os.path.join(path_out_abs, file_moco_params_y),
squeeze_data=False)
generate_output_file(file_moco_params_csv,
os.path.join(path_out_abs, file_moco_params_csv))
# Delete temporary files
if param.remove_temp_files == 1:
printv('\nDelete temporary files...', param.verbose)
rmtree(path_tmp, verbose=param.verbose)
# come back to working directory
os.chdir(curdir)
# display elapsed time
elapsed_time = time.time() - start_time
printv('\nElapsed time: ' + str(int(np.round(elapsed_time))) + 's',
param.verbose)
fname_moco = os.path.join(
param.path_out,
add_suffix(os.path.basename(param.fname_data), param.suffix))
return fname_moco
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_loglevel(verbose=verbose)
# initialize parameters
param = Param()
fname_data = arguments.i
fname_bvecs = arguments.bvec
average = arguments.a
remove_temp_files = arguments.r
path_out = arguments.ofolder
fname_bvals = arguments.bval
if arguments.bvalmin:
param.bval_min = arguments.bvalmin
# Initialization
start_time = time.time()
# printv(arguments)
printv('\nInput parameters:', verbose)
printv(' input file ............' + fname_data, verbose)
printv(' bvecs file ............' + fname_bvecs, verbose)
printv(' bvals file ............' + fname_bvals, verbose)
printv(' average ...............' + str(average), verbose)
# Get full path
fname_data = os.path.abspath(fname_data)
fname_bvecs = os.path.abspath(fname_bvecs)
if fname_bvals:
fname_bvals = os.path.abspath(fname_bvals)
# Extract path, file and extension
path_data, file_data, ext_data = extract_fname(fname_data)
# create temporary folder
path_tmp = tmp_create(basename="dmri_separate")
# copy files into tmp folder and convert to nifti
printv('\nCopy files into temporary folder...', verbose)
ext = '.nii'
dmri_name = 'dmri'
b0_name = file_data + '_b0'
b0_mean_name = b0_name + '_mean'
dwi_name = file_data + '_dwi'
dwi_mean_name = dwi_name + '_mean'
im_dmri = convert(Image(fname_data))
im_dmri.save(os.path.join(path_tmp, dmri_name + ext),
mutable=True,
verbose=verbose)
copy(fname_bvecs, os.path.join(path_tmp, "bvecs"), verbose=verbose)
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Get size of data
printv('\nGet dimensions data...', verbose)
nx, ny, nz, nt, px, py, pz, pt = im_dmri.dim
printv(
'.. ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' + str(nt),
verbose)
# Identify b=0 and DWI images
printv(fname_bvals)
index_b0, index_dwi, nb_b0, nb_dwi = identify_b0(fname_bvecs, fname_bvals,
param.bval_min, verbose)
# Split into T dimension
printv('\nSplit along T dimension...', verbose)
im_dmri_split_list = split_data(im_dmri, 3)
for im_d in im_dmri_split_list:
im_d.save()
# Merge b=0 images
printv('\nMerge b=0...', verbose)
fname_in_list_b0 = []
for it in range(nb_b0):
fname_in_list_b0.append(dmri_name + '_T' + str(index_b0[it]).zfill(4) +
ext)
im_in_list_b0 = [Image(fname) for fname in fname_in_list_b0]
concat_data(im_in_list_b0, 3).save(b0_name + ext)
# Average b=0 images
if average:
printv('\nAverage b=0...', verbose)
img = Image(b0_name + ext)
out = img.copy()
dim_idx = 3
if len(np.shape(img.data)) < dim_idx + 1:
raise ValueError("Expecting image with 4 dimensions!")
out.data = np.mean(out.data, dim_idx)
out.save(path=b0_mean_name + ext)
# Merge DWI
fname_in_list_dwi = []
for it in range(nb_dwi):
fname_in_list_dwi.append(dmri_name + '_T' +
str(index_dwi[it]).zfill(4) + ext)
im_in_list_dwi = [Image(fname) for fname in fname_in_list_dwi]
concat_data(im_in_list_dwi, 3).save(dwi_name + ext)
# Average DWI images
if average:
printv('\nAverage DWI...', verbose)
img = Image(dwi_name + ext)
out = img.copy()
dim_idx = 3
if len(np.shape(img.data)) < dim_idx + 1:
raise ValueError("Expecting image with 4 dimensions!")
out.data = np.mean(out.data, dim_idx)
out.save(path=dwi_mean_name + ext)
# come back
os.chdir(curdir)
# Generate output files
fname_b0 = os.path.abspath(os.path.join(path_out, b0_name + ext_data))
fname_dwi = os.path.abspath(os.path.join(path_out, dwi_name + ext_data))
fname_b0_mean = os.path.abspath(
os.path.join(path_out, b0_mean_name + ext_data))
fname_dwi_mean = os.path.abspath(
os.path.join(path_out, dwi_mean_name + ext_data))
printv('\nGenerate output files...', verbose)
generate_output_file(os.path.join(path_tmp, b0_name + ext),
fname_b0,
verbose=verbose)
generate_output_file(os.path.join(path_tmp, dwi_name + ext),
fname_dwi,
verbose=verbose)
if average:
generate_output_file(os.path.join(path_tmp, b0_mean_name + ext),
fname_b0_mean,
verbose=verbose)
generate_output_file(os.path.join(path_tmp, dwi_mean_name + ext),
fname_dwi_mean,
verbose=verbose)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
printv(
'\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's',
verbose)
return fname_b0, fname_b0_mean, fname_dwi, fname_dwi_mean
def main():
# Initialization
fname_data = ''
interp_factor = param.interp_factor
remove_temp_files = param.remove_temp_files
verbose = param.verbose
suffix = param.suffix
smoothing_sigma = param.smoothing_sigma
# start timer
start_time = time.time()
# Parameters for debug mode
if param.debug:
fname_data = os.path.join(__data_dir__, 'sct_testing_data', 't2', 't2_seg.nii.gz')
remove_temp_files = 0
param.mask_size = 10
else:
# Check input parameters
try:
opts, args = getopt.getopt(sys.argv[1:], 'hi:v:r:s:')
except getopt.GetoptError:
usage()
raise SystemExit(2)
if not opts:
usage()
raise SystemExit(2)
for opt, arg in opts:
if opt == '-h':
usage()
return
elif opt in ('-i'):
fname_data = arg
elif opt in ('-r'):
remove_temp_files = int(arg)
elif opt in ('-s'):
smoothing_sigma = arg
elif opt in ('-v'):
verbose = int(arg)
# display usage if a mandatory argument is not provided
if fname_data == '':
usage()
raise SystemExit(2)
# printv(arguments)
printv('\nCheck parameters:')
printv(' segmentation ........... ' + fname_data)
printv(' interp factor .......... ' + str(interp_factor))
printv(' smoothing sigma ........ ' + str(smoothing_sigma))
# check existence of input files
printv('\nCheck existence of input files...')
check_file_exist(fname_data, verbose)
# Extract path, file and extension
path_data, file_data, ext_data = extract_fname(fname_data)
path_tmp = tmp_create(basename="binary_to_trilinear")
printv('\nCopying input data to tmp folder and convert to nii...', param.verbose)
im_input = convert(Image(fname_data))
im_input.save(os.path.join(path_tmp, "data.nii"), mutable=True, verbose=param.verbose)
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Get dimensions of data
printv('\nGet dimensions of data...', verbose)
nx, ny, nz, nt, px, py, pz, pt = Image('data.nii').dim
printv('.. ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz), verbose)
# upsample data
printv('\nUpsample data...', verbose)
run_proc(["sct_resample",
"-i", "data.nii",
"-x", "linear",
"-vox", str(nx * interp_factor) + 'x' + str(ny * interp_factor) + 'x' + str(nz * interp_factor),
"-o", "data_up.nii"], verbose)
# Smooth along centerline
printv('\nSmooth along centerline...', verbose)
run_proc(["sct_smooth_spinalcord",
"-i", "data_up.nii",
"-s", "data_up.nii",
"-smooth", str(smoothing_sigma),
"-r", str(remove_temp_files),
"-v", str(verbose)], verbose)
# downsample data
printv('\nDownsample data...', verbose)
run_proc(["sct_resample",
"-i", "data_up_smooth.nii",
"-x", "linear",
"-vox", str(nx) + 'x' + str(ny) + 'x' + str(nz),
"-o", "data_up_smooth_down.nii"], verbose)
# come back
os.chdir(curdir)
# Generate output files
printv('\nGenerate output files...')
fname_out = generate_output_file(os.path.join(path_tmp, "data_up_smooth_down.nii"), '' + file_data + suffix + ext_data)
# Delete 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')
# to view results
printv('\nTo view results, type:')
printv('fslview ' + file_data + ' ' + file_data + suffix + ' &\n')
