def apply_transfo(im_src, im_dest, warp, interp='spline', rm_tmp=True):
# create tmp dir and go in it
tmp_dir = tmp_create()
# copy warping field to tmp dir
copy(warp, tmp_dir)
warp = ''.join(extract_fname(warp)[1:])
# go to tmp dir
curdir = os.getcwd()
os.chdir(tmp_dir)
# save image and seg
fname_src = 'src.nii.gz'
im_src.save(fname_src)
fname_dest = 'dest.nii.gz'
im_dest.save(fname_dest)
# apply warping field
fname_src_reg = add_suffix(fname_src, '_reg')
sct_apply_transfo.main(
argv=['-i', fname_src, '-d', fname_dest, '-w', warp, '-x', interp])
im_src_reg = Image(fname_src_reg)
# get out of tmp dir
os.chdir(curdir)
if rm_tmp:
# remove tmp dir
rmtree(tmp_dir)
# return res image
return im_src_reg
def create_line(param, fname, coord, nz):
"""
Create vertical line in 3D volume
:param param:
:param fname:
:param coord:
:param nz:
:return:
"""
# duplicate volume (assumes input file is nifti)
copy(fname, 'line.nii', verbose=param.verbose)
# set all voxels to zero
run_proc(['sct_maths', '-i', 'line.nii', '-mul', '0', '-o', 'line.nii'], param.verbose)
labels = []
if isinstance(coord[0], Coordinate):
for x, y, _, _ in coord:
labels.extend([Coordinate([x, y, iz, 1]) for iz in range(nz)])
else:
# backwards compat
labels.extend([Coordinate([coord[0], coord[1], iz, 1]) for iz in range(nz)])
create_labels(Image("line.nii"), labels).save(path="line.nii")
return 'line.nii'
def create_line(param, fname, coord, nz):
"""
Create vertical line in 3D volume
:param param:
:param fname:
:param coord:
:param nz:
:return:
"""
# duplicate volume (assumes input file is nifti)
copy(fname, 'line.nii', verbose=param.verbose)
# set all voxels to zero
img = Image('line.nii')
data = get_data_or_scalar('0', img.data)
data_concat = concatenate_along_4th_dimension(img.data, data)
img.data = np.prod(data_concat, axis=3)
img.save()
labels = []
if isinstance(coord[0], Coordinate):
for x, y, _, _ in coord:
labels.extend([Coordinate([x, y, iz, 1]) for iz in range(nz)])
else:
# backwards compat
labels.extend(
[Coordinate([coord[0], coord[1], iz, 1]) for iz in range(nz)])
create_labels(img, labels).save()
return 'line.nii'
def ifolder2tmp(self):
# copy input image
if self.fname_mask is not None:
copy(self.fname_mask, self.tmp_dir)
self.fname_mask = ''.join(extract_fname(self.fname_mask)[1:])
else:
printv('ERROR: No input image', self.verbose, 'error')
# copy seg image
if self.fname_sc is not None:
copy(self.fname_sc, self.tmp_dir)
self.fname_sc = ''.join(extract_fname(self.fname_sc)[1:])
# copy ref image
if self.fname_ref is not None:
copy(self.fname_ref, self.tmp_dir)
self.fname_ref = ''.join(extract_fname(self.fname_ref)[1:])
# copy registered template
if self.path_template is not None:
copy(self.path_levels, self.tmp_dir)
self.path_levels = ''.join(extract_fname(self.path_levels)[1:])
self.atlas_roi_lst = []
for fname_atlas_roi in os.listdir(self.path_atlas):
if fname_atlas_roi.endswith('.nii.gz'):
tract_id = int(
fname_atlas_roi.split('_')[-1].split('.nii.gz')[0])
if tract_id < 36: # Not interested in CSF
copy(os.path.join(self.path_atlas, fname_atlas_roi),
self.tmp_dir)
self.atlas_roi_lst.append(fname_atlas_roi)
os.chdir(self.tmp_dir) # go to tmp directory
def register_data(im_src, im_dest, param_reg, path_copy_warp=None, rm_tmp=True):
'''
Parameters
----------
im_src: class Image: source image
im_dest: class Image: destination image
param_reg: str: registration parameter
path_copy_warp: path: path to copy the warping fields
Returns: im_src_reg: class Image: source image registered on destination image
-------
'''
# im_src and im_dest are already preprocessed (in theory: im_dest = mean_image)
# binarize images to get seg
im_src_seg = binarize(im_src, thr_min=1, thr_max=1)
im_dest_seg = binarize(im_dest)
# create tmp dir and go in it
tmp_dir = tmp_create()
curdir = os.getcwd()
os.chdir(tmp_dir)
# save image and seg
fname_src = 'src.nii.gz'
im_src.save(fname_src)
fname_src_seg = 'src_seg.nii.gz'
im_src_seg.save(fname_src_seg)
fname_dest = 'dest.nii.gz'
im_dest.save(fname_dest)
fname_dest_seg = 'dest_seg.nii.gz'
im_dest_seg.save(fname_dest_seg)
# do registration using param_reg
sct_register_multimodal.main(args=['-i', fname_src,
'-d', fname_dest,
'-iseg', fname_src_seg,
'-dseg', fname_dest_seg,
'-param', param_reg])
# get registration result
fname_src_reg = add_suffix(fname_src, '_reg')
im_src_reg = Image(fname_src_reg)
# get out of tmp dir
os.chdir(curdir)
# copy warping fields
if path_copy_warp is not None and os.path.isdir(os.path.abspath(path_copy_warp)):
path_copy_warp = os.path.abspath(path_copy_warp)
file_src = extract_fname(fname_src)[1]
file_dest = extract_fname(fname_dest)[1]
fname_src2dest = 'warp_' + file_src + '2' + file_dest + '.nii.gz'
fname_dest2src = 'warp_' + file_dest + '2' + file_src + '.nii.gz'
copy(os.path.join(tmp_dir, fname_src2dest), path_copy_warp)
copy(os.path.join(tmp_dir, fname_dest2src), path_copy_warp)
if rm_tmp:
# remove tmp dir
rmtree(tmp_dir)
# return res image
return im_src_reg, fname_src2dest, fname_dest2src
def tmp2ofolder(self):
os.chdir(self.wrk_dir) # go back to working directory
printv('\nSave results files...', self.verbose, 'normal')
printv('\n... measures saved in the files:', self.verbose, 'normal')
for file_ in [self.fname_label, self.excel_name, self.pickle_name]:
printv('\n - ' + os.path.join(self.path_ofolder, file_), self.verbose, 'normal')
copy(os.path.join(self.tmp_dir, file_), os.path.join(self.path_ofolder, file_))
def tmp2ofolder(self):
os.chdir(self.curdir) # go back to original directory
printv('\nSave resulting files...', self.param.verbose, 'normal')
for f in self.fname_metric_lst: # Copy from tmp folder to ofolder
copy(os.path.join(self.tmp_dir, self.fname_metric_lst[f]),
os.path.join(self.param.path_results, self.fname_metric_lst[f]))
def load_manual_gmseg(list_slices_target,
list_fname_manual_gmseg,
tmp_dir,
im_sc_seg_rpi,
new_res,
square_size_size_mm,
for_model=False,
fname_mask=None):
if isinstance(list_fname_manual_gmseg, str):
# consider fname_manual_gmseg as a list of file names to allow multiple manual GM segmentation
list_fname_manual_gmseg = [list_fname_manual_gmseg]
curdir = os.getcwd()
for fname_manual_gmseg in list_fname_manual_gmseg:
copy(fname_manual_gmseg, tmp_dir)
# change fname level to only file name (path = tmp dir now)
path_gm, file_gm, ext_gm = extract_fname(fname_manual_gmseg)
fname_manual_gmseg = file_gm + ext_gm
os.chdir(tmp_dir)
im_manual_gmseg = Image(fname_manual_gmseg).change_orientation("RPI")
if fname_mask is not None:
cropper = ImageCropper(im_manual_gmseg)
cropper.get_bbox_from_mask(fname_mask)
im_manual_gmseg_crop = cropper.crop()
im_manual_gmseg = im_manual_gmseg_crop
# assert gmseg has the right number of slices
assert im_manual_gmseg.data.shape[2] == len(
list_slices_target
), 'ERROR: the manual GM segmentation has not the same number of slices than the image.'
# interpolate gm to reference image
nz_gmseg, nx_gmseg, ny_gmseg, nt_gmseg, pz_gmseg, px_gmseg, py_gmseg, pt_gmseg = im_manual_gmseg.dim
list_im_gm = interpolate_im_to_ref(im_manual_gmseg,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm,
interpolation_mode=0)
# load gm seg in list of slices
n_poped = 0
for im_gm, slice_im in zip(list_im_gm, list_slices_target):
if im_gm.data.max() == 0 and for_model:
list_slices_target.pop(slice_im.id - n_poped)
n_poped += 1
else:
slice_im.gm_seg.append(im_gm.data)
wm_slice = (slice_im.im > 0) - im_gm.data
slice_im.wm_seg.append(wm_slice)
os.chdir(curdir)
return list_slices_target
def tmp2ofolder(self):
"""Copy output files to the ofolder."""
os.chdir(self.curdir) # go back to original directory
if self.pa_coord != -1: # If PMJ has been detected
printv('\nSave resulting file...', self.verbose, 'normal')
copy(os.path.abspath(os.path.join(self.tmp_dir, self.fname_out)),
os.path.abspath(os.path.join(self.path_out, self.fname_out)))
return os.path.join(self.path_out, self.fname_out)
else:
return None
def centerline2roi(fname_image, folder_output='.', verbose=0):
"""
Tis method converts a binary centerline image to a .roi centerline file
:param fname_image: filename of the binary centerline image, in RPI orientation
:param folder_output: path to output folder where to copy .roi centerline
:param verbose: adjusts the verbosity of the logging.
:returns: filename of the .roi centerline that has been created
"""
# TODO: change folder_output to fname_out
path_data, file_data, ext_data = extract_fname(fname_image)
fname_output = file_data + '.roi'
date_now = datetime.datetime.now()
ROI_TEMPLATE = 'Begin Marker ROI\n' \
' Build version="7.0_33"\n' \
' Annotation=""\n' \
' Colour=0\n' \
' Image source="{fname_segmentation}"\n' \
' Created "{creation_date}" by Operator ID="SCT"\n' \
' Slice={slice_num}\n' \
' Begin Shape\n' \
' X={position_x}; Y={position_y}\n' \
' End Shape\n' \
'End Marker ROI\n'
im = Image(fname_image)
nx, ny, nz, nt, px, py, pz, pt = im.dim
coordinates_centerline = im.getNonZeroCoordinates(sorting='z')
f = open(fname_output, "w")
logger.info("Writing ROI file...")
for coord in coordinates_centerline:
coord_phys_center = im.transfo_pix2phys([[(nx - 1) / 2.0,
(ny - 1) / 2.0, coord.z]])[0]
coord_phys = im.transfo_pix2phys([[coord.x, coord.y, coord.z]])[0]
f.write(
ROI_TEMPLATE.format(
fname_segmentation=fname_image,
creation_date=date_now.strftime("%d %B %Y %H:%M:%S.%f %Z"),
slice_num=coord.z + 1,
position_x=coord_phys_center[0] - coord_phys[0],
position_y=coord_phys_center[1] - coord_phys[1]))
f.close()
if os.path.abspath(folder_output) != os.getcwd():
copy(fname_output, folder_output)
return fname_output
def ifolder2tmp(self):
"""Copy data to tmp folder."""
if self.fname_im is not None: # copy input image
copy(self.fname_im, self.tmp_dir)
self.fname_im = ''.join(extract_fname(self.fname_im)[1:])
else:
printv('ERROR: No input image', self.verbose, 'error')
if self.fname_seg is not None: # copy segmentation image
copy(self.fname_seg, self.tmp_dir)
self.fname_seg = ''.join(extract_fname(self.fname_seg)[1:])
self.curdir = os.getcwd()
os.chdir(self.tmp_dir) # go to tmp directory
def ifolder2tmp(self):
self.curdir = os.getcwd()
# copy input image
if self.param.fname_im is not None:
copy(self.param.fname_im, self.tmp_dir)
self.param.fname_im = ''.join(extract_fname(self.param.fname_im)[1:])
else:
printv('ERROR: No input image', self.param.verbose, 'error')
# copy masked image
if self.param.fname_seg is not None:
copy(self.param.fname_seg, self.tmp_dir)
self.param.fname_seg = ''.join(extract_fname(self.param.fname_seg)[1:])
else:
printv('ERROR: No mask image', self.param.verbose, 'error')
os.chdir(self.tmp_dir) # go to tmp directory
def warp_label(path_label, folder_label, file_label, fname_src, fname_transfo,
path_out, list_labels_nn, verbose):
"""
Warp label files according to info_label.txt file
:param path_label:
:param folder_label:
:param file_label:
:param fname_src:
:param fname_transfo:
:param path_out:
:param list_labels_nn:
:param verbose:
:return:
"""
try:
# Read label file
template_label_ids, template_label_names, template_label_file, combined_labels_ids, combined_labels_names, \
combined_labels_id_groups, clusters_apriori = \
spinalcordtoolbox.metadata.read_label_file(os.path.join(path_label, folder_label), file_label)
except Exception as error:
printv(
'\nWARNING: Cannot warp label ' + folder_label + ': ' + str(error),
1, 'warning')
raise
else:
# create output folder
if not os.path.exists(os.path.join(path_out, folder_label)):
os.makedirs(os.path.join(path_out, folder_label))
# Warp label
for i in range(0, len(template_label_file)):
fname_label = os.path.join(path_label, folder_label,
template_label_file[i])
# apply transfo
run_proc(
'isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
(fname_label, fname_src, fname_transfo,
os.path.join(path_out, folder_label, template_label_file[i]),
get_interp(template_label_file[i], list_labels_nn)),
is_sct_binary=True,
verbose=verbose)
# Copy list.txt
copy(os.path.join(path_label, folder_label, file_label),
os.path.join(path_out, folder_label))
def warp_label(path_label, folder_label, file_label, fname_src, fname_transfo,
path_out, list_labels_nn, verbose):
"""
Warp label files according to info_label.txt file
:param path_label:
:param folder_label:
:param file_label:
:param fname_src:
:param fname_transfo:
:param path_out:
:param list_labels_nn:
:param verbose:
:return:
"""
try:
# Read label file
template_label_ids, template_label_names, template_label_file, combined_labels_ids, combined_labels_names, \
combined_labels_id_groups, clusters_apriori = \
spinalcordtoolbox.metadata.read_label_file(os.path.join(path_label, folder_label), file_label)
except Exception as error:
printv(
'\nWARNING: Cannot warp label ' + folder_label + ': ' + str(error),
1, 'warning')
raise
else:
# create output folder
if not os.path.exists(os.path.join(path_out, folder_label)):
os.makedirs(os.path.join(path_out, folder_label))
# Warp label
for i in range(0, len(template_label_file)):
fname_label = os.path.join(path_label, folder_label,
template_label_file[i])
# apply transfo
sct_apply_transfo.main([
'-i', fname_label, '-d', fname_src, '-w', fname_transfo, '-o',
os.path.join(path_out, folder_label, template_label_file[i]),
'-x',
get_interp(template_label_file[i], list_labels_nn), '-v', '0'
])
# Copy list.txt
copy(os.path.join(path_label, folder_label, file_label),
os.path.join(path_out, folder_label))
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)
file_target = "target.nii.gz"
convert(param.file_target, file_target, 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 == '':
convert(param.fname_mask, file_mask, squeeze_data=False, 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 main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_loglevel(verbose=verbose)
fname_in = os.path.abspath(arguments.i)
fname_seg = os.path.abspath(arguments.s)
contrast = arguments.c
path_template = os.path.abspath(arguments.t)
scale_dist = arguments.scale_dist
path_output = os.path.abspath(arguments.ofolder)
fname_disc = arguments.discfile
if fname_disc is not None:
fname_disc = os.path.abspath(fname_disc)
initz = arguments.initz
initcenter = arguments.initcenter
fname_initlabel = arguments.initlabel
if fname_initlabel is not None:
fname_initlabel = os.path.abspath(fname_initlabel)
remove_temp_files = arguments.r
clean_labels = arguments.clean_labels
path_tmp = tmp_create(basename="label_vertebrae")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder...', verbose)
Image(fname_in).save(os.path.join(path_tmp, "data.nii"))
Image(fname_seg).save(os.path.join(path_tmp, "segmentation.nii"))
# Go go temp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Straighten spinal cord
printv('\nStraighten spinal cord...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
cache_sig = cache_signature(input_files=[fname_in, fname_seg], )
fname_cache = "straightening.cache"
if (cache_valid(os.path.join(curdir, fname_cache), 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
s, o = run_proc([
'sct_apply_transfo', '-i', 'data.nii', '-w',
'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o',
'data_straight.nii'
])
else:
sct_straighten_spinalcord.main(argv=[
'-i',
'data.nii',
'-s',
'segmentation.nii',
'-r',
str(remove_temp_files),
'-v',
'0',
])
cache_save(os.path.join(path_output, fname_cache), cache_sig)
# resample to 0.5mm isotropic to match template resolution
printv('\nResample to 0.5mm isotropic...', verbose)
s, o = run_proc([
'sct_resample', '-i', 'data_straight.nii', '-mm', '0.5x0.5x0.5', '-x',
'linear', '-o', 'data_straightr.nii'
],
verbose=verbose)
# Apply straightening to segmentation
# N.B. Output is RPI
printv('\nApply straightening to segmentation...', verbose)
sct_apply_transfo.main([
'-i', 'segmentation.nii', '-d', 'data_straightr.nii', '-w',
'warp_curve2straight.nii.gz', '-o', 'segmentation_straight.nii', '-x',
'linear', '-v', '0'
])
# Threshold segmentation at 0.5
img = Image('segmentation_straight.nii')
img.data = threshold(img.data, 0.5)
img.save()
# If disc label file is provided, label vertebrae using that file instead of automatically
if fname_disc:
# Apply straightening to disc-label
printv('\nApply straightening to disc labels...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
(fname_disc, 'data_straightr.nii', 'warp_curve2straight.nii.gz',
'labeldisc_straight.nii.gz', 'label'),
verbose=verbose)
label_vert('segmentation_straight.nii',
'labeldisc_straight.nii.gz',
verbose=1)
else:
printv('\nCreate label to identify disc...', verbose)
fname_labelz = os.path.join(path_tmp, 'labelz.nii.gz')
if initcenter is not None:
# find z centered in FOV
nii = Image('segmentation.nii').change_orientation("RPI")
nx, ny, nz, nt, px, py, pz, pt = nii.dim
z_center = round(nz / 2)
initz = [z_center, initcenter]
if initz is not None:
im_label = create_labels_along_segmentation(
Image('segmentation.nii'), [tuple(initz)])
im_label.save(fname_labelz)
elif fname_initlabel is not None:
Image(fname_initlabel).save(fname_labelz)
else:
# automatically finds C2-C3 disc
im_data = Image('data.nii')
im_seg = Image('segmentation.nii')
# because verbose is also used for keeping temp files
verbose_detect_c2c3 = 0 if remove_temp_files else 2
im_label_c2c3 = detect_c2c3(im_data,
im_seg,
contrast,
verbose=verbose_detect_c2c3)
ind_label = np.where(im_label_c2c3.data)
if np.size(ind_label) == 0:
printv(
'Automatic C2-C3 detection failed. Please provide manual label with sct_label_utils',
1, 'error')
sys.exit(1)
im_label_c2c3.data[ind_label] = 3
im_label_c2c3.save(fname_labelz)
# dilate label so it is not lost when applying warping
dilate(Image(fname_labelz), 3, 'ball').save(fname_labelz)
# Apply straightening to z-label
printv('\nAnd apply straightening to label...', verbose)
sct_apply_transfo.main([
'-i', 'labelz.nii.gz', '-d', 'data_straightr.nii', '-w',
'warp_curve2straight.nii.gz', '-o', 'labelz_straight.nii.gz', '-x',
'nn', '-v', '0'
])
# get z value and disk value to initialize labeling
printv('\nGet z and disc values from straight label...', verbose)
init_disc = get_z_and_disc_values_from_label('labelz_straight.nii.gz')
printv('.. ' + str(init_disc), verbose)
# apply laplacian filtering
if arguments.laplacian:
printv('\nApply Laplacian filter...', verbose)
img = Image("data_straightr.nii")
# apply std dev to each axis of the image
sigmas = [1 for i in range(len(img.data.shape))]
# adjust sigma based on voxel size
sigmas = [sigmas[i] / img.dim[i + 4] for i in range(3)]
# smooth data
img.data = laplacian(img.data, sigmas)
img.save()
# detect vertebral levels on straight spinal cord
init_disc[1] = init_disc[1] - 1
vertebral_detection('data_straightr.nii',
'segmentation_straight.nii',
contrast,
arguments.param,
init_disc=init_disc,
verbose=verbose,
path_template=path_template,
path_output=path_output,
scale_dist=scale_dist)
# un-straighten labeled spinal cord
printv('\nUn-straighten labeling...', verbose)
sct_apply_transfo.main([
'-i', 'segmentation_straight_labeled.nii', '-d', 'segmentation.nii',
'-w', 'warp_straight2curve.nii.gz', '-o', 'segmentation_labeled.nii',
'-x', 'nn', '-v', '0'
])
if clean_labels >= 1:
printv('\nCleaning labeled segmentation:', verbose)
im_labeled_seg = Image('segmentation_labeled.nii')
im_seg = Image('segmentation.nii')
if clean_labels >= 2:
printv(' filling in missing label voxels ...', verbose)
expand_labels(im_labeled_seg)
printv(' removing labeled voxels outside segmentation...', verbose)
crop_labels(im_labeled_seg, im_seg)
printv('Done cleaning.', verbose)
im_labeled_seg.save()
# label discs
printv('\nLabel discs...', verbose)
printv('\nUn-straighten labeled discs...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
('segmentation_straight_labeled_disc.nii', 'segmentation.nii',
'warp_straight2curve.nii.gz', 'segmentation_labeled_disc.nii',
'label'),
verbose=verbose,
is_sct_binary=True,
)
# come back
os.chdir(curdir)
# Generate output files
path_seg, file_seg, ext_seg = extract_fname(fname_seg)
fname_seg_labeled = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
printv('\nGenerate output files...', verbose)
generate_output_file(os.path.join(path_tmp, "segmentation_labeled.nii"),
fname_seg_labeled)
generate_output_file(
os.path.join(path_tmp, "segmentation_labeled_disc.nii"),
os.path.join(path_output, file_seg + '_labeled_discs' + ext_seg))
# copy straightening files in case subsequent SCT functions need them
generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"),
os.path.join(path_output,
"warp_curve2straight.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"),
os.path.join(path_output,
"warp_straight2curve.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"),
os.path.join(path_output, "straight_ref.nii.gz"),
verbose=verbose)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp)
# Generate QC report
if arguments.qc is not None:
path_qc = os.path.abspath(arguments.qc)
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
labeled_seg_file = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
generate_qc(fname_in,
fname_seg=labeled_seg_file,
args=argv,
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_label_vertebrae')
display_viewer_syntax([fname_in, fname_seg_labeled],
colormaps=['', 'subcortical'],
opacities=['1', '0.5'])
def main(args=None):
# initialize parameters
param = Param()
# call main function
parser = get_parser()
if args:
arguments = parser.parse_args(args)
else:
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_data = arguments.i
fname_bvecs = arguments.bvec
average = arguments.a
verbose = int(arguments.v)
init_sct(log_level=verbose, update=True) # Update log level
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'
if not convert(fname_data, os.path.join(path_tmp, dmri_name + ext)):
printv('ERROR in convert.', 1, 'error')
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
im_dmri = Image(dmri_name + ext)
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)
from sct_image import concat_data
l = []
for it in range(nb_b0):
l.append(dmri_name + '_T' + str(index_b0[it]).zfill(4) + ext)
im_out = concat_data(l, 3).save(b0_name + ext)
# Average b=0 images
if average:
printv('\nAverage b=0...', verbose)
run_proc(['sct_maths', '-i', b0_name + ext, '-o', b0_mean_name + ext, '-mean', 't'], verbose)
# Merge DWI
l = []
for it in range(nb_dwi):
l.append(dmri_name + '_T' + str(index_dwi[it]).zfill(4) + ext)
im_out = concat_data(l, 3).save(dwi_name + ext)
# Average DWI images
if average:
printv('\nAverage DWI...', verbose)
run_proc(['sct_maths', '-i', dwi_name + ext, '-o', dwi_mean_name + ext, '-mean', 't'], verbose)
# 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(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_loglevel(verbose=verbose)
param = Param()
if param.debug:
printv('\n*** WARNING: DEBUG MODE ON ***\n')
else:
input_fname = arguments.i
input_second_fname = ''
output_fname = 'hausdorff_distance.txt'
resample_to = 0.1
if arguments.d is not None:
input_second_fname = arguments.d
if arguments.thinning is not None:
param.thinning = bool(arguments.thinning)
if arguments.resampling is not None:
resample_to = arguments.resampling
if arguments.o is not None:
output_fname = arguments.o
param.verbose = verbose
tmp_dir = tmp_create()
im1_name = "im1.nii.gz"
copy(input_fname, os.path.join(tmp_dir, im1_name))
if input_second_fname != '':
im2_name = 'im2.nii.gz'
copy(input_second_fname, os.path.join(tmp_dir, im2_name))
else:
im2_name = None
curdir = os.getcwd()
os.chdir(tmp_dir)
# now = time.time()
input_im1 = Image(
resample_image(im1_name,
binary=True,
thr=0.5,
npx=resample_to,
npy=resample_to))
input_im1.absolutepath = os.path.basename(input_fname)
if im2_name is not None:
input_im2 = Image(
resample_image(im2_name,
binary=True,
thr=0.5,
npx=resample_to,
npy=resample_to))
input_im2.absolutepath = os.path.basename(input_second_fname)
else:
input_im2 = None
computation = ComputeDistances(input_im1, im2=input_im2, param=param)
# TODO change back the orientatin of the thinned image
if param.thinning:
computation.thinning1.thinned_image.save(
os.path.join(
curdir,
add_suffix(os.path.basename(input_fname), '_thinned')))
if im2_name is not None:
computation.thinning2.thinned_image.save(
os.path.join(
curdir,
add_suffix(os.path.basename(input_second_fname),
'_thinned')))
os.chdir(curdir)
res_fic = open(output_fname, 'w')
res_fic.write(computation.res)
res_fic.write('\n\nInput 1: ' + input_fname)
res_fic.write('\nInput 2: ' + input_second_fname)
res_fic.close()
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv if argv else ['--help'])
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# initializations
initz = ''
initcenter = ''
fname_initlabel = ''
file_labelz = 'labelz.nii.gz'
param = Param()
fname_in = os.path.abspath(arguments.i)
fname_seg = os.path.abspath(arguments.s)
contrast = arguments.c
path_template = os.path.abspath(arguments.t)
scale_dist = arguments.scale_dist
path_output = arguments.ofolder
param.path_qc = arguments.qc
if arguments.discfile is not None:
fname_disc = os.path.abspath(arguments.discfile)
else:
fname_disc = None
if arguments.initz is not None:
initz = arguments.initz
if len(initz) != 2:
raise ValueError(
'--initz takes two arguments: position in superior-inferior direction, label value'
)
if arguments.initcenter is not None:
initcenter = arguments.initcenter
# if user provided text file, parse and overwrite arguments
if arguments.initfile is not None:
file = open(arguments.initfile, 'r')
initfile = ' ' + file.read().replace('\n', '')
arg_initfile = initfile.split(' ')
for idx_arg, arg in enumerate(arg_initfile):
if arg == '-initz':
initz = [int(x) for x in arg_initfile[idx_arg + 1].split(',')]
if len(initz) != 2:
raise ValueError(
'--initz takes two arguments: position in superior-inferior direction, label value'
)
if arg == '-initcenter':
initcenter = int(arg_initfile[idx_arg + 1])
if arguments.initlabel is not None:
# get absolute path of label
fname_initlabel = os.path.abspath(arguments.initlabel)
if arguments.param is not None:
param.update(arguments.param[0])
remove_temp_files = arguments.r
clean_labels = arguments.clean_labels
laplacian = arguments.laplacian
path_tmp = tmp_create(basename="label_vertebrae")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder...', verbose)
Image(fname_in).save(os.path.join(path_tmp, "data.nii"))
Image(fname_seg).save(os.path.join(path_tmp, "segmentation.nii"))
# Go go temp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Straighten spinal cord
printv('\nStraighten spinal cord...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
cache_sig = cache_signature(input_files=[fname_in, fname_seg], )
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
s, o = run_proc([
'sct_apply_transfo', '-i', 'data.nii', '-w',
'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o',
'data_straight.nii'
])
else:
sct_straighten_spinalcord.main(argv=[
'-i',
'data.nii',
'-s',
'segmentation.nii',
'-r',
str(remove_temp_files),
'-v',
str(verbose),
])
cache_save(cachefile, cache_sig)
# resample to 0.5mm isotropic to match template resolution
printv('\nResample to 0.5mm isotropic...', verbose)
s, o = run_proc([
'sct_resample', '-i', 'data_straight.nii', '-mm', '0.5x0.5x0.5', '-x',
'linear', '-o', 'data_straightr.nii'
],
verbose=verbose)
# Apply straightening to segmentation
# N.B. Output is RPI
printv('\nApply straightening to segmentation...', verbose)
run_proc(
'isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation.nii', 'data_straightr.nii',
'warp_curve2straight.nii.gz', 'segmentation_straight.nii', 'Linear'),
verbose=verbose,
is_sct_binary=True,
)
# Threshold segmentation at 0.5
run_proc([
'sct_maths', '-i', 'segmentation_straight.nii', '-thr', '0.5', '-o',
'segmentation_straight.nii'
], verbose)
# If disc label file is provided, label vertebrae using that file instead of automatically
if fname_disc:
# Apply straightening to disc-label
printv('\nApply straightening to disc labels...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
(fname_disc, 'data_straightr.nii', 'warp_curve2straight.nii.gz',
'labeldisc_straight.nii.gz', 'label'),
verbose=verbose)
label_vert('segmentation_straight.nii',
'labeldisc_straight.nii.gz',
verbose=1)
else:
# create label to identify disc
printv('\nCreate label to identify disc...', verbose)
fname_labelz = os.path.join(path_tmp, file_labelz)
if initz or initcenter:
if initcenter:
# find z centered in FOV
nii = Image('segmentation.nii').change_orientation("RPI")
nx, ny, nz, nt, px, py, pz, pt = nii.dim # Get dimensions
z_center = int(np.round(nz / 2)) # get z_center
initz = [z_center, initcenter]
im_label = create_labels_along_segmentation(
Image('segmentation.nii'), [(initz[0], initz[1])])
im_label.data = dilate(im_label.data, 3, 'ball')
im_label.save(fname_labelz)
elif fname_initlabel:
Image(fname_initlabel).save(fname_labelz)
else:
# automatically finds C2-C3 disc
im_data = Image('data.nii')
im_seg = Image('segmentation.nii')
if not remove_temp_files: # because verbose is here also used for keeping temp files
verbose_detect_c2c3 = 2
else:
verbose_detect_c2c3 = 0
im_label_c2c3 = detect_c2c3(im_data,
im_seg,
contrast,
verbose=verbose_detect_c2c3)
ind_label = np.where(im_label_c2c3.data)
if not np.size(ind_label) == 0:
im_label_c2c3.data[ind_label] = 3
else:
printv(
'Automatic C2-C3 detection failed. Please provide manual label with sct_label_utils',
1, 'error')
sys.exit()
im_label_c2c3.save(fname_labelz)
# dilate label so it is not lost when applying warping
dilate(Image(fname_labelz), 3, 'ball').save(fname_labelz)
# Apply straightening to z-label
printv('\nAnd apply straightening to label...', verbose)
run_proc(
'isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
(file_labelz, 'data_straightr.nii', 'warp_curve2straight.nii.gz',
'labelz_straight.nii.gz', 'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
# get z value and disk value to initialize labeling
printv('\nGet z and disc values from straight label...', verbose)
init_disc = get_z_and_disc_values_from_label('labelz_straight.nii.gz')
printv('.. ' + str(init_disc), verbose)
# apply laplacian filtering
if laplacian:
printv('\nApply Laplacian filter...', verbose)
run_proc([
'sct_maths', '-i', 'data_straightr.nii', '-laplacian', '1',
'-o', 'data_straightr.nii'
], verbose)
# detect vertebral levels on straight spinal cord
init_disc[1] = init_disc[1] - 1
vertebral_detection('data_straightr.nii',
'segmentation_straight.nii',
contrast,
param,
init_disc=init_disc,
verbose=verbose,
path_template=path_template,
path_output=path_output,
scale_dist=scale_dist)
# un-straighten labeled spinal cord
printv('\nUn-straighten labeling...', verbose)
run_proc(
'isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation_straight_labeled.nii', 'segmentation.nii',
'warp_straight2curve.nii.gz', 'segmentation_labeled.nii',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
if clean_labels:
# Clean labeled segmentation
printv(
'\nClean labeled segmentation (correct interpolation errors)...',
verbose)
clean_labeled_segmentation('segmentation_labeled.nii',
'segmentation.nii',
'segmentation_labeled.nii')
# label discs
printv('\nLabel discs...', verbose)
printv('\nUn-straighten labeled discs...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
('segmentation_straight_labeled_disc.nii', 'segmentation.nii',
'warp_straight2curve.nii.gz', 'segmentation_labeled_disc.nii',
'label'),
verbose=verbose,
is_sct_binary=True,
)
# come back
os.chdir(curdir)
# Generate output files
path_seg, file_seg, ext_seg = extract_fname(fname_seg)
fname_seg_labeled = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
printv('\nGenerate output files...', verbose)
generate_output_file(os.path.join(path_tmp, "segmentation_labeled.nii"),
fname_seg_labeled)
generate_output_file(
os.path.join(path_tmp, "segmentation_labeled_disc.nii"),
os.path.join(path_output, file_seg + '_labeled_discs' + ext_seg))
# copy straightening files in case subsequent SCT functions need them
generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"),
os.path.join(path_output,
"warp_curve2straight.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"),
os.path.join(path_output,
"warp_straight2curve.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"),
os.path.join(path_output, "straight_ref.nii.gz"),
verbose=verbose)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp)
# Generate QC report
if param.path_qc is not None:
path_qc = os.path.abspath(arguments.qc)
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
labeled_seg_file = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
generate_qc(fname_in,
fname_seg=labeled_seg_file,
args=argv,
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_label_vertebrae')
display_viewer_syntax([fname_in, fname_seg_labeled],
colormaps=['', 'subcortical'],
opacities=['1', '0.5'])
def straighten(self):
"""
Straighten spinal cord. Steps: (everything is done in physical space)
1. open input image and centreline image
2. extract bspline fitting of the centreline, and its derivatives
3. compute length of centerline
4. compute and generate straight space
5. compute transformations
for each voxel of one space: (done using matrices --> improves speed by a factor x300)
a. determine which plane of spinal cord centreline it is included
b. compute the position of the voxel in the plane (X and Y distance from centreline, along the plane)
c. find the correspondant centreline point in the other space
d. find the correspondance of the voxel in the corresponding plane
6. generate warping fields for each transformations
7. write warping fields and apply them
step 5.b: how to find the corresponding plane?
The centerline plane corresponding to a voxel correspond to the nearest point of the centerline.
However, we need to compute the distance between the voxel position and the plane to be sure it is part of the plane and not too distant.
If it is more far than a threshold, warping value should be 0.
step 5.d: how to make the correspondance between centerline point in both images?
Both centerline have the same lenght. Therefore, we can map centerline point via their position along the curve.
If we use the same number of points uniformely along the spinal cord (1000 for example), the correspondance is straight-forward.
:return:
"""
# Initialization
fname_anat = self.input_filename
fname_centerline = self.centerline_filename
fname_output = self.output_filename
remove_temp_files = self.remove_temp_files
verbose = self.verbose
interpolation_warp = self.interpolation_warp # TODO: remove this
# start timer
start_time = time.time()
# Extract path/file/extension
path_anat, file_anat, ext_anat = extract_fname(fname_anat)
path_tmp = tmp_create(basename="straighten_spinalcord")
# Copying input data to tmp folder
logger.info('Copy files to tmp folder...')
Image(fname_anat,
check_sform=True).save(os.path.join(path_tmp, "data.nii"))
Image(fname_centerline, check_sform=True).save(
os.path.join(path_tmp, "centerline.nii.gz"))
if self.use_straight_reference:
Image(self.centerline_reference_filename, check_sform=True).save(
os.path.join(path_tmp, "centerline_ref.nii.gz"))
if self.discs_input_filename != '':
Image(self.discs_input_filename, check_sform=True).save(
os.path.join(path_tmp, "labels_input.nii.gz"))
if self.discs_ref_filename != '':
Image(self.discs_ref_filename, check_sform=True).save(
os.path.join(path_tmp, "labels_ref.nii.gz"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Change orientation of the input centerline into RPI
image_centerline = Image("centerline.nii.gz").change_orientation(
"RPI").save("centerline_rpi.nii.gz", mutable=True)
# Get dimension
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
if self.speed_factor != 1.0:
intermediate_resampling = True
px_r, py_r, pz_r = px * self.speed_factor, py * self.speed_factor, pz * self.speed_factor
else:
intermediate_resampling = False
if intermediate_resampling:
mv('centerline_rpi.nii.gz', 'centerline_rpi_native.nii.gz')
pz_native = pz
# TODO: remove system call
run_proc([
'sct_resample', '-i', 'centerline_rpi_native.nii.gz', '-mm',
str(px_r) + 'x' + str(py_r) + 'x' + str(pz_r), '-o',
'centerline_rpi.nii.gz'
])
image_centerline = Image('centerline_rpi.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
if np.min(image_centerline.data) < 0 or np.max(
image_centerline.data) > 1:
image_centerline.data[image_centerline.data < 0] = 0
image_centerline.data[image_centerline.data > 1] = 1
image_centerline.save()
# 2. extract bspline fitting of the centerline, and its derivatives
img_ctl = Image('centerline_rpi.nii.gz')
centerline = _get_centerline(img_ctl, self.param_centerline, verbose)
number_of_points = centerline.number_of_points
# ==========================================================================================
logger.info('Create the straight space and the safe zone')
# 3. compute length of centerline
# compute the length of the spinal cord based on fitted centerline and size of centerline in z direction
# Computation of the safe zone.
# The safe zone is defined as the length of the spinal cord for which an axial segmentation will be complete
# The safe length (to remove) is computed using the safe radius (given as parameter) and the angle of the
# last centerline point with the inferior-superior direction. Formula: Ls = Rs * sin(angle)
# Calculate Ls for both edges and remove appropriate number of centerline points
radius_safe = 0.0 # mm
# inferior edge
u = centerline.derivatives[0]
v = np.array([0, 0, -1])
angle_inferior = np.arctan2(np.linalg.norm(np.cross(u, v)),
np.dot(u, v))
length_safe_inferior = radius_safe * np.sin(angle_inferior)
# superior edge
u = centerline.derivatives[-1]
v = np.array([0, 0, 1])
angle_superior = np.arctan2(np.linalg.norm(np.cross(u, v)),
np.dot(u, v))
length_safe_superior = radius_safe * np.sin(angle_superior)
# remove points
inferior_bound = bisect.bisect(centerline.progressive_length,
length_safe_inferior) - 1
superior_bound = centerline.number_of_points - bisect.bisect(
centerline.progressive_length_inverse, length_safe_superior)
z_centerline = centerline.points[:, 2]
length_centerline = centerline.length
size_z_centerline = z_centerline[-1] - z_centerline[0]
# compute the size factor between initial centerline and straight bended centerline
factor_curved_straight = length_centerline / size_z_centerline
middle_slice = (z_centerline[0] + z_centerline[-1]) / 2.0
bound_curved = [
z_centerline[inferior_bound], z_centerline[superior_bound]
]
bound_straight = [(z_centerline[inferior_bound] - middle_slice) *
factor_curved_straight + middle_slice,
(z_centerline[superior_bound] - middle_slice) *
factor_curved_straight + middle_slice]
logger.info('Length of spinal cord: {}'.format(length_centerline))
logger.info(
'Size of spinal cord in z direction: {}'.format(size_z_centerline))
logger.info('Ratio length/size: {}'.format(factor_curved_straight))
logger.info(
'Safe zone boundaries (curved space): {}'.format(bound_curved))
logger.info(
'Safe zone boundaries (straight space): {}'.format(bound_straight))
# 4. compute and generate straight space
# points along curved centerline are already regularly spaced.
# calculate position of points along straight centerline
# Create straight NIFTI volumes.
# ==========================================================================================
# TODO: maybe this if case is not needed?
if self.use_straight_reference:
image_centerline_pad = Image('centerline_rpi.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline_pad.dim
fname_ref = 'centerline_ref_rpi.nii.gz'
image_centerline_straight = Image('centerline_ref.nii.gz') \
.change_orientation("RPI") \
.save(fname_ref, mutable=True)
centerline_straight = _get_centerline(image_centerline_straight,
self.param_centerline,
verbose)
nx_s, ny_s, nz_s, nt_s, px_s, py_s, pz_s, pt_s = image_centerline_straight.dim
# Prepare warping fields headers
hdr_warp = image_centerline_pad.hdr.copy()
hdr_warp.set_data_dtype('float32')
hdr_warp_s = image_centerline_straight.hdr.copy()
hdr_warp_s.set_data_dtype('float32')
if self.discs_input_filename != "" and self.discs_ref_filename != "":
discs_input_image = Image('labels_input.nii.gz')
coord = discs_input_image.getNonZeroCoordinates(
sorting='z', reverse_coord=True)
coord_physical = []
for c in coord:
c_p = discs_input_image.transfo_pix2phys([[c.x, c.y, c.z]
]).tolist()[0]
c_p.append(c.value)
coord_physical.append(c_p)
centerline.compute_vertebral_distribution(coord_physical)
centerline.save_centerline(
image=discs_input_image,
fname_output='discs_input_image.nii.gz')
discs_ref_image = Image('labels_ref.nii.gz')
coord = discs_ref_image.getNonZeroCoordinates(
sorting='z', reverse_coord=True)
coord_physical = []
for c in coord:
c_p = discs_ref_image.transfo_pix2phys([[c.x, c.y,
c.z]]).tolist()[0]
c_p.append(c.value)
coord_physical.append(c_p)
centerline_straight.compute_vertebral_distribution(
coord_physical)
centerline_straight.save_centerline(
image=discs_ref_image,
fname_output='discs_ref_image.nii.gz')
else:
logger.info(
'Pad input volume to account for spinal cord length...')
start_point, end_point = bound_straight[0], bound_straight[1]
offset_z = 0
# if the destination image is resampled, we still create the straight reference space with the native
# resolution.
# TODO: Maybe this if case is not needed?
if intermediate_resampling:
padding_z = int(
np.ceil(1.5 *
((length_centerline - size_z_centerline) / 2.0) /
pz_native))
run_proc([
'sct_image', '-i', 'centerline_rpi_native.nii.gz', '-o',
'tmp.centerline_pad_native.nii.gz', '-pad',
'0,0,' + str(padding_z)
])
image_centerline_pad = Image('centerline_rpi_native.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline_pad.dim
start_point_coord_native = image_centerline_pad.transfo_phys2pix(
[[0, 0, start_point]])[0]
end_point_coord_native = image_centerline_pad.transfo_phys2pix(
[[0, 0, end_point]])[0]
straight_size_x = int(self.xy_size / px)
straight_size_y = int(self.xy_size / py)
warp_space_x = [
int(np.round(nx / 2)) - straight_size_x,
int(np.round(nx / 2)) + straight_size_x
]
warp_space_y = [
int(np.round(ny / 2)) - straight_size_y,
int(np.round(ny / 2)) + straight_size_y
]
if warp_space_x[0] < 0:
warp_space_x[1] += warp_space_x[0] - 2
warp_space_x[0] = 0
if warp_space_y[0] < 0:
warp_space_y[1] += warp_space_y[0] - 2
warp_space_y[0] = 0
spec = dict((
(0, warp_space_x),
(1, warp_space_y),
(2, (0, end_point_coord_native[2] -
start_point_coord_native[2])),
))
spatial_crop(
Image("tmp.centerline_pad_native.nii.gz"),
spec).save("tmp.centerline_pad_crop_native.nii.gz")
fname_ref = 'tmp.centerline_pad_crop_native.nii.gz'
offset_z = 4
else:
fname_ref = 'tmp.centerline_pad_crop.nii.gz'
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
padding_z = int(
np.ceil(1.5 * ((length_centerline - size_z_centerline) / 2.0) /
pz)) + offset_z
image_centerline_pad = pad_image(image_centerline,
pad_z_i=padding_z,
pad_z_f=padding_z)
nx, ny, nz = image_centerline_pad.data.shape
hdr_warp = image_centerline_pad.hdr.copy()
hdr_warp.set_data_dtype('float32')
start_point_coord = image_centerline_pad.transfo_phys2pix(
[[0, 0, start_point]])[0]
end_point_coord = image_centerline_pad.transfo_phys2pix(
[[0, 0, end_point]])[0]
straight_size_x = int(self.xy_size / px)
straight_size_y = int(self.xy_size / py)
warp_space_x = [
int(np.round(nx / 2)) - straight_size_x,
int(np.round(nx / 2)) + straight_size_x
]
warp_space_y = [
int(np.round(ny / 2)) - straight_size_y,
int(np.round(ny / 2)) + straight_size_y
]
if warp_space_x[0] < 0:
warp_space_x[1] += warp_space_x[0] - 2
warp_space_x[0] = 0
if warp_space_x[1] >= nx:
warp_space_x[1] = nx - 1
if warp_space_y[0] < 0:
warp_space_y[1] += warp_space_y[0] - 2
warp_space_y[0] = 0
if warp_space_y[1] >= ny:
warp_space_y[1] = ny - 1
spec = dict((
(0, warp_space_x),
(1, warp_space_y),
(2, (0, end_point_coord[2] - start_point_coord[2] + offset_z)),
))
image_centerline_straight = spatial_crop(image_centerline_pad,
spec)
nx_s, ny_s, nz_s, nt_s, px_s, py_s, pz_s, pt_s = image_centerline_straight.dim
hdr_warp_s = image_centerline_straight.hdr.copy()
hdr_warp_s.set_data_dtype('float32')
if self.template_orientation == 1:
raise NotImplementedError()
start_point_coord = image_centerline_pad.transfo_phys2pix(
[[0, 0, start_point]])[0]
end_point_coord = image_centerline_pad.transfo_phys2pix(
[[0, 0, end_point]])[0]
number_of_voxel = nx * ny * nz
logger.debug('Number of voxels: {}'.format(number_of_voxel))
time_centerlines = time.time()
coord_straight = np.empty((number_of_points, 3))
coord_straight[..., 0] = int(np.round(nx_s / 2))
coord_straight[..., 1] = int(np.round(ny_s / 2))
coord_straight[..., 2] = np.linspace(
0, end_point_coord[2] - start_point_coord[2], number_of_points)
coord_phys_straight = image_centerline_straight.transfo_pix2phys(
coord_straight)
derivs_straight = np.empty((number_of_points, 3))
derivs_straight[..., 0] = derivs_straight[..., 1] = 0
derivs_straight[..., 2] = 1
dx_straight, dy_straight, dz_straight = derivs_straight.T
centerline_straight = Centerline(coord_phys_straight[:, 0],
coord_phys_straight[:, 1],
coord_phys_straight[:, 2],
dx_straight, dy_straight,
dz_straight)
time_centerlines = time.time() - time_centerlines
logger.info('Time to generate centerline: {} ms'.format(
np.round(time_centerlines * 1000.0)))
if verbose == 2:
# TODO: use OO
import matplotlib.pyplot as plt
from datetime import datetime
curved_points = centerline.progressive_length
straight_points = centerline_straight.progressive_length
range_points = np.linspace(0, 1, number_of_points)
dist_curved = np.zeros(number_of_points)
dist_straight = np.zeros(number_of_points)
for i in range(1, number_of_points):
dist_curved[i] = dist_curved[
i - 1] + curved_points[i - 1] / centerline.length
dist_straight[i] = dist_straight[i - 1] + straight_points[
i - 1] / centerline_straight.length
plt.plot(range_points, dist_curved)
plt.plot(range_points, dist_straight)
plt.grid(True)
plt.savefig('fig_straighten_' +
datetime.now().strftime("%y%m%d%H%M%S%f") + '.png')
plt.close()
# alignment_mode = 'length'
alignment_mode = 'levels'
lookup_curved2straight = list(range(centerline.number_of_points))
if self.discs_input_filename != "":
# create look-up table curved to straight
for index in range(centerline.number_of_points):
disc_label = centerline.l_points[index]
if alignment_mode == 'length':
relative_position = centerline.dist_points[index]
else:
relative_position = centerline.dist_points_rel[index]
idx_closest = centerline_straight.get_closest_to_absolute_position(
disc_label,
relative_position,
backup_index=index,
backup_centerline=centerline_straight,
mode=alignment_mode)
if idx_closest is not None:
lookup_curved2straight[index] = idx_closest
else:
lookup_curved2straight[index] = 0
for p in range(0, len(lookup_curved2straight) // 2):
if lookup_curved2straight[p] == lookup_curved2straight[p + 1]:
lookup_curved2straight[p] = 0
else:
break
for p in range(
len(lookup_curved2straight) - 1,
len(lookup_curved2straight) // 2, -1):
if lookup_curved2straight[p] == lookup_curved2straight[p - 1]:
lookup_curved2straight[p] = 0
else:
break
lookup_curved2straight = np.array(lookup_curved2straight)
lookup_straight2curved = list(
range(centerline_straight.number_of_points))
if self.discs_input_filename != "":
for index in range(centerline_straight.number_of_points):
disc_label = centerline_straight.l_points[index]
if alignment_mode == 'length':
relative_position = centerline_straight.dist_points[index]
else:
relative_position = centerline_straight.dist_points_rel[
index]
idx_closest = centerline.get_closest_to_absolute_position(
disc_label,
relative_position,
backup_index=index,
backup_centerline=centerline_straight,
mode=alignment_mode)
if idx_closest is not None:
lookup_straight2curved[index] = idx_closest
for p in range(0, len(lookup_straight2curved) // 2):
if lookup_straight2curved[p] == lookup_straight2curved[p + 1]:
lookup_straight2curved[p] = 0
else:
break
for p in range(
len(lookup_straight2curved) - 1,
len(lookup_straight2curved) // 2, -1):
if lookup_straight2curved[p] == lookup_straight2curved[p - 1]:
lookup_straight2curved[p] = 0
else:
break
lookup_straight2curved = np.array(lookup_straight2curved)
# Create volumes containing curved and straight warping fields
data_warp_curved2straight = np.zeros((nx_s, ny_s, nz_s, 1, 3))
data_warp_straight2curved = np.zeros((nx, ny, nz, 1, 3))
# 5. compute transformations
# Curved and straight images and the same dimensions, so we compute both warping fields at the same time.
# b. determine which plane of spinal cord centreline it is included
if self.curved2straight:
for u in sct_progress_bar(range(nz_s)):
x_s, y_s, z_s = np.mgrid[0:nx_s, 0:ny_s, u:u + 1]
indexes_straight = np.array(
list(zip(x_s.ravel(), y_s.ravel(), z_s.ravel())))
physical_coordinates_straight = image_centerline_straight.transfo_pix2phys(
indexes_straight)
nearest_indexes_straight = centerline_straight.find_nearest_indexes(
physical_coordinates_straight)
distances_straight = centerline_straight.get_distances_from_planes(
physical_coordinates_straight, nearest_indexes_straight)
lookup = lookup_straight2curved[nearest_indexes_straight]
indexes_out_distance_straight = np.logical_or(
np.logical_or(
distances_straight > self.threshold_distance,
distances_straight < -self.threshold_distance),
lookup == 0)
projected_points_straight = centerline_straight.get_projected_coordinates_on_planes(
physical_coordinates_straight, nearest_indexes_straight)
coord_in_planes_straight = centerline_straight.get_in_plans_coordinates(
projected_points_straight, nearest_indexes_straight)
coord_straight2curved = centerline.get_inverse_plans_coordinates(
coord_in_planes_straight, lookup)
displacements_straight = coord_straight2curved - physical_coordinates_straight
# Invert Z coordinate as ITK & ANTs physical coordinate system is LPS- (RAI+)
# while ours is LPI-
# Refs: https://sourceforge.net/p/advants/discussion/840261/thread/2a1e9307/#fb5a
# https://www.slicer.org/wiki/Coordinate_systems
displacements_straight[:, 2] = -displacements_straight[:, 2]
displacements_straight[indexes_out_distance_straight] = [
100000.0, 100000.0, 100000.0
]
data_warp_curved2straight[indexes_straight[:, 0], indexes_straight[:, 1], indexes_straight[:, 2], 0, :]\
= -displacements_straight
if self.straight2curved:
for u in sct_progress_bar(range(nz)):
x, y, z = np.mgrid[0:nx, 0:ny, u:u + 1]
indexes = np.array(list(zip(x.ravel(), y.ravel(), z.ravel())))
physical_coordinates = image_centerline_pad.transfo_pix2phys(
indexes)
nearest_indexes_curved = centerline.find_nearest_indexes(
physical_coordinates)
distances_curved = centerline.get_distances_from_planes(
physical_coordinates, nearest_indexes_curved)
lookup = lookup_curved2straight[nearest_indexes_curved]
indexes_out_distance_curved = np.logical_or(
np.logical_or(distances_curved > self.threshold_distance,
distances_curved < -self.threshold_distance),
lookup == 0)
projected_points_curved = centerline.get_projected_coordinates_on_planes(
physical_coordinates, nearest_indexes_curved)
coord_in_planes_curved = centerline.get_in_plans_coordinates(
projected_points_curved, nearest_indexes_curved)
coord_curved2straight = centerline_straight.points[lookup]
coord_curved2straight[:, 0:2] += coord_in_planes_curved[:, 0:2]
coord_curved2straight[:, 2] += distances_curved
displacements_curved = coord_curved2straight - physical_coordinates
displacements_curved[:, 2] = -displacements_curved[:, 2]
displacements_curved[indexes_out_distance_curved] = [
100000.0, 100000.0, 100000.0
]
data_warp_straight2curved[indexes[:, 0], indexes[:, 1],
indexes[:, 2],
0, :] = -displacements_curved
# Creation of the safe zone based on pre-calculated safe boundaries
coord_bound_curved_inf, coord_bound_curved_sup = image_centerline_pad.transfo_phys2pix(
[[0, 0, bound_curved[0]]]), image_centerline_pad.transfo_phys2pix(
[[0, 0, bound_curved[1]]])
coord_bound_straight_inf, coord_bound_straight_sup = image_centerline_straight.transfo_phys2pix(
[[0, 0,
bound_straight[0]]]), image_centerline_straight.transfo_phys2pix(
[[0, 0, bound_straight[1]]])
if radius_safe > 0:
data_warp_curved2straight[:, :, 0:coord_bound_straight_inf[0][2],
0, :] = 100000.0
data_warp_curved2straight[:, :, coord_bound_straight_sup[0][2]:,
0, :] = 100000.0
data_warp_straight2curved[:, :, 0:coord_bound_curved_inf[0][2],
0, :] = 100000.0
data_warp_straight2curved[:, :, coord_bound_curved_sup[0][2]:,
0, :] = 100000.0
# Generate warp files as a warping fields
hdr_warp_s.set_intent('vector', (), '')
hdr_warp_s.set_data_dtype('float32')
hdr_warp.set_intent('vector', (), '')
hdr_warp.set_data_dtype('float32')
if self.curved2straight:
img = Nifti1Image(data_warp_curved2straight, None, hdr_warp_s)
save(img, 'tmp.curve2straight.nii.gz')
logger.info('Warping field generated: tmp.curve2straight.nii.gz')
if self.straight2curved:
img = Nifti1Image(data_warp_straight2curved, None, hdr_warp)
save(img, 'tmp.straight2curve.nii.gz')
logger.info('Warping field generated: tmp.straight2curve.nii.gz')
image_centerline_straight.save(fname_ref)
if self.curved2straight:
logger.info('Apply transformation to input image...')
run_proc([
'isct_antsApplyTransforms', '-d', '3', '-r', fname_ref, '-i',
'data.nii', '-o', 'tmp.anat_rigid_warp.nii.gz', '-t',
'tmp.curve2straight.nii.gz', '-n', 'BSpline[3]'
],
is_sct_binary=True,
verbose=verbose)
if self.accuracy_results:
time_accuracy_results = time.time()
# compute the error between the straightened centerline/segmentation and the central vertical line.
# Ideally, the error should be zero.
# Apply deformation to input image
logger.info('Apply transformation to centerline image...')
run_proc([
'isct_antsApplyTransforms', '-d', '3', '-r', fname_ref, '-i',
'centerline.nii.gz', '-o', 'tmp.centerline_straight.nii.gz',
'-t', 'tmp.curve2straight.nii.gz', '-n', 'NearestNeighbor'
],
is_sct_binary=True,
verbose=verbose)
file_centerline_straight = Image('tmp.centerline_straight.nii.gz',
verbose=verbose)
nx, ny, nz, nt, px, py, pz, pt = file_centerline_straight.dim
coordinates_centerline = file_centerline_straight.getNonZeroCoordinates(
sorting='z')
mean_coord = []
for z in range(coordinates_centerline[0].z,
coordinates_centerline[-1].z):
temp_mean = [
coord.value for coord in coordinates_centerline
if coord.z == z
]
if temp_mean:
mean_value = np.mean(temp_mean)
mean_coord.append(
np.mean([[
coord.x * coord.value / mean_value,
coord.y * coord.value / mean_value
] for coord in coordinates_centerline if coord.z == z],
axis=0))
# compute error between the straightened centerline and the straight line.
x0 = file_centerline_straight.data.shape[0] / 2.0
y0 = file_centerline_straight.data.shape[1] / 2.0
count_mean = 0
if number_of_points >= 10:
mean_c = mean_coord[
2:
-2] # we don't include the four extrema because there are usually messy.
else:
mean_c = mean_coord
for coord_z in mean_c:
if not np.isnan(np.sum(coord_z)):
dist = ((x0 - coord_z[0]) * px)**2 + (
(y0 - coord_z[1]) * py)**2
self.mse_straightening += dist
dist = np.sqrt(dist)
if dist > self.max_distance_straightening:
self.max_distance_straightening = dist
count_mean += 1
self.mse_straightening = np.sqrt(self.mse_straightening /
float(count_mean))
self.elapsed_time_accuracy = time.time() - time_accuracy_results
os.chdir(curdir)
# Generate output file (in current folder)
# TODO: do not uncompress the warping field, it is too time consuming!
logger.info('Generate output files...')
if self.curved2straight:
generate_output_file(
os.path.join(path_tmp, "tmp.curve2straight.nii.gz"),
os.path.join(self.path_output, "warp_curve2straight.nii.gz"),
verbose)
if self.straight2curved:
generate_output_file(
os.path.join(path_tmp, "tmp.straight2curve.nii.gz"),
os.path.join(self.path_output, "warp_straight2curve.nii.gz"),
verbose)
# create ref_straight.nii.gz file that can be used by other SCT functions that need a straight reference space
if self.curved2straight:
copy(os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output, "straight_ref.nii.gz"))
# move straightened input file
if fname_output == '':
fname_straight = generate_output_file(
os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output,
file_anat + "_straight" + ext_anat), verbose)
else:
fname_straight = generate_output_file(
os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output, fname_output),
verbose) # straightened anatomic
# Remove temporary files
if remove_temp_files:
logger.info('Remove temporary files...')
rmtree(path_tmp)
if self.accuracy_results:
logger.info('Maximum x-y error: {} mm'.format(
self.max_distance_straightening))
logger.info('Accuracy of straightening (MSE): {} mm'.format(
self.mse_straightening))
# display elapsed time
self.elapsed_time = int(np.round(time.time() - start_time))
return fname_straight
init_sct()
parser = get_parser()
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_input1 = arguments.i
fname_input2 = arguments.d
verbose = arguments.v
init_sct(log_level=verbose, update=True) # Update log level
tmp_dir = tmp_create() # create tmp directory
tmp_dir = os.path.abspath(tmp_dir)
# copy input files to tmp directory
# for fname in [fname_input1, fname_input2]:
copy(fname_input1, tmp_dir)
copy(fname_input2, tmp_dir)
fname_input1 = ''.join(extract_fname(fname_input1)[1:])
fname_input2 = ''.join(extract_fname(fname_input2)[1:])
curdir = os.getcwd()
os.chdir(tmp_dir) # go to tmp directory
if arguments.bin is not None:
fname_input1_bin = add_suffix(fname_input1, '_bin')
run_proc([
'sct_maths', '-i', fname_input1, '-bin', '0', '-o',
fname_input1_bin
])
fname_input1 = fname_input1_bin
fname_input2_bin = add_suffix(fname_input2, '_bin')
def pre_processing(fname_target,
fname_sc_seg,
fname_level=None,
fname_manual_gmseg=None,
new_res=0.3,
square_size_size_mm=22.5,
denoising=True,
verbose=1,
rm_tmp=True,
for_model=False):
printv('\nPre-process data...', verbose, 'normal')
tmp_dir = tmp_create()
copy(fname_target, tmp_dir)
fname_target = ''.join(extract_fname(fname_target)[1:])
copy(fname_sc_seg, tmp_dir)
fname_sc_seg = ''.join(extract_fname(fname_sc_seg)[1:])
curdir = os.getcwd()
os.chdir(tmp_dir)
original_info = {
'orientation': None,
'im_sc_seg_rpi': None,
'interpolated_images': []
}
im_target = Image(fname_target).copy()
im_sc_seg = Image(fname_sc_seg).copy()
# get original orientation
printv(' Reorient...', verbose, 'normal')
original_info['orientation'] = im_target.orientation
# assert images are in the same orientation
assert im_target.orientation == im_sc_seg.orientation, "ERROR: the image to segment and it's SC segmentation are not in the same orientation"
im_target_rpi = im_target.copy().change_orientation(
'RPI', generate_path=True).save()
im_sc_seg_rpi = im_sc_seg.copy().change_orientation(
'RPI', generate_path=True).save()
original_info['im_sc_seg_rpi'] = im_sc_seg_rpi.copy(
) # target image in RPI will be used to post-process segmentations
# denoise using P. Coupe non local means algorithm (see [Manjon et al. JMRI 2010]) implemented in dipy
if denoising:
printv(' Denoise...', verbose, 'normal')
# crop image before denoising to fasten denoising
nx, ny, nz, nt, px, py, pz, pt = im_target_rpi.dim
size_x, size_y = (square_size_size_mm + 1) / px, (square_size_size_mm +
1) / py
size = int(np.ceil(max(size_x, size_y)))
# create mask
fname_mask = 'mask_pre_crop.nii.gz'
sct_create_mask.main([
'-i', im_target_rpi.absolutepath, '-p',
'centerline,' + im_sc_seg_rpi.absolutepath, '-f', 'box', '-size',
str(size), '-o', fname_mask
])
# crop image
cropper = ImageCropper(im_target_rpi)
cropper.get_bbox_from_mask(Image(fname_mask))
im_target_rpi_crop = cropper.crop()
# crop segmentation
cropper = ImageCropper(im_sc_seg_rpi)
cropper.get_bbox_from_mask(Image(fname_mask))
im_sc_seg_rpi_crop = cropper.crop()
# denoising
from spinalcordtoolbox.math import denoise_nlmeans
block_radius = 3
block_radius = int(
im_target_rpi_crop.data.shape[2] /
2) if im_target_rpi_crop.data.shape[2] < (block_radius *
2) else block_radius
patch_radius = block_radius - 1
data_denoised = denoise_nlmeans(im_target_rpi_crop.data,
block_radius=block_radius,
patch_radius=patch_radius)
im_target_rpi_crop.data = data_denoised
im_target_rpi = im_target_rpi_crop
im_sc_seg_rpi = im_sc_seg_rpi_crop
else:
fname_mask = None
# interpolate image to reference square image (resample and square crop centered on SC)
printv(' Interpolate data to the model space...', verbose, 'normal')
list_im_slices = interpolate_im_to_ref(im_target_rpi,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm)
original_info[
'interpolated_images'] = list_im_slices # list of images (not Slice() objects)
printv(' Mask data using the spinal cord segmentation...', verbose,
'normal')
list_sc_seg_slices = interpolate_im_to_ref(
im_sc_seg_rpi,
im_sc_seg_rpi,
new_res=new_res,
sq_size_size_mm=square_size_size_mm,
interpolation_mode=1)
for i in range(len(list_im_slices)):
# list_im_slices[i].data[list_sc_seg_slices[i].data == 0] = 0
list_sc_seg_slices[i] = binarize(list_sc_seg_slices[i],
thr_min=0.5,
thr_max=1)
list_im_slices[
i].data = list_im_slices[i].data * list_sc_seg_slices[i].data
printv(' Split along rostro-caudal direction...', verbose, 'normal')
list_slices_target = [
Slice(slice_id=i, im=im_slice.data, gm_seg=[], wm_seg=[])
for i, im_slice in enumerate(list_im_slices)
]
# load vertebral levels
if fname_level is not None:
printv(' Load vertebral levels...', verbose, 'normal')
# copy level file to tmp dir
os.chdir(curdir)
copy(fname_level, tmp_dir)
os.chdir(tmp_dir)
# change fname level to only file name (path = tmp dir now)
fname_level = ''.join(extract_fname(fname_level)[1:])
# load levels
list_slices_target = load_level(list_slices_target, fname_level)
os.chdir(curdir)
# load manual gmseg if there is one (model data)
if fname_manual_gmseg is not None:
printv('\n\tLoad manual GM segmentation(s) ...', verbose, 'normal')
list_slices_target = load_manual_gmseg(list_slices_target,
fname_manual_gmseg,
tmp_dir,
im_sc_seg_rpi,
new_res,
square_size_size_mm,
for_model=for_model,
fname_mask=fname_mask)
if rm_tmp:
# remove tmp folder
rmtree(tmp_dir)
return list_slices_target, original_info
resample_to = 0.1
if arguments.d is not None:
input_second_fname = arguments.d
if arguments.thinning is not None:
param.thinning = bool(arguments.thinning)
if arguments.resampling is not None:
resample_to = arguments.resampling
if arguments.o is not None:
output_fname = arguments.o
param.verbose = arguments.v
init_sct(log_level=param.verbose, update=True) # Update log level
tmp_dir = tmp_create()
im1_name = "im1.nii.gz"
copy(input_fname, os.path.join(tmp_dir, im1_name))
if input_second_fname != '':
im2_name = 'im2.nii.gz'
copy(input_second_fname, os.path.join(tmp_dir, im2_name))
else:
im2_name = None
curdir = os.getcwd()
os.chdir(tmp_dir)
# now = time.time()
input_im1 = Image(
resample_image(im1_name,
binary=True,
thr=0.5,
npx=resample_to,
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_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'
if not convert(fname_data, os.path.join(path_tmp, dmri_name + ext)):
printv('ERROR in convert.', 1, 'error')
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
im_dmri = Image(dmri_name + ext)
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 register(param, file_src, file_dest, file_mat, file_out, im_mask=None):
"""
Register two images by estimating slice-wise Tx and Ty transformations, which are regularized along Z. This function
uses ANTs' isct_antsSliceRegularizedRegistration.
:param param:
:param file_src:
:param file_dest:
:param file_mat:
:param file_out:
:param im_mask: Image of mask, could be 2D or 3D
:return:
"""
# TODO: deal with mask
# initialization
failed_transfo = 0 # by default, failed matrix is 0 (i.e., no failure)
do_registration = True
# get metric radius (if MeanSquares, CC) or nb bins (if MI)
if param.metric == 'MI':
metric_radius = '16'
else:
metric_radius = '4'
file_out_concat = file_out
kw = dict()
im_data = Image(
file_src
) # TODO: pass argument to use antsReg instead of opening Image each time
# register file_src to file_dest
if param.todo == 'estimate' or param.todo == 'estimate_and_apply':
# If orientation is sagittal, use antsRegistration in 2D mode
# Note: the parameter --restrict-deformation is irrelevant with affine transfo
if param.sampling == 'None':
# 'None' sampling means 'fully dense' sampling
# see https://github.com/ANTsX/ANTs/wiki/antsRegistration-reproducibility-issues
sampling = param.sampling
else:
# param.sampling should be a float in [0,1], and means the
# samplingPercentage that chooses a subset of points to
# estimate from. We always use 'Regular' (evenly-spaced)
# mode, though antsRegistration offers 'Random' as well.
# Be aware: even 'Regular' is not fully deterministic:
# > Regular includes a random perturbation on the grid sampling
# - https://github.com/ANTsX/ANTs/issues/976#issuecomment-602313884
sampling = 'Regular,' + param.sampling
if im_data.orientation[2] in 'LR':
cmd = [
'isct_antsRegistration', '-d', '2', '--transform',
'Affine[%s]' % param.gradStep, '--metric',
param.metric + '[' + file_dest + ',' + file_src + ',1,' +
metric_radius + ',' + sampling + ']', '--convergence',
param.iter, '--shrink-factors', '1', '--smoothing-sigmas',
param.smooth, '--verbose', '1', '--output',
'[' + file_mat + ',' + file_out_concat + ']'
]
cmd += get_interpolation('isct_antsRegistration', param.interp)
if im_mask is not None:
# if user specified a mask, make sure there are non-null voxels in the image before running the registration
if np.count_nonzero(im_mask.data):
cmd += ['--masks', im_mask.absolutepath]
else:
# Mask only contains zeros. Copying the image instead of estimating registration.
copy(file_src, file_out_concat, verbose=0)
do_registration = False
# TODO: create affine mat file with identity, in case used by -g 2
# 3D mode
else:
cmd = [
'isct_antsSliceRegularizedRegistration', '--polydegree',
param.poly, '--transform',
'Translation[%s]' % param.gradStep, '--metric',
param.metric + '[' + file_dest + ',' + file_src + ',1,' +
metric_radius + ',' + sampling + ']', '--iterations',
param.iter, '--shrinkFactors', '1', '--smoothingSigmas',
param.smooth, '--verbose', '1', '--output',
'[' + file_mat + ',' + file_out_concat + ']'
]
cmd += get_interpolation('isct_antsSliceRegularizedRegistration',
param.interp)
if im_mask is not None:
cmd += ['--mask', im_mask.absolutepath]
# run command
if do_registration:
kw.update(dict(is_sct_binary=True))
# reducing the number of CPU used for moco (see issue #201 and #2642)
env = {
**os.environ,
**{
"ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS": "1"
}
}
status, output = run_proc(cmd,
verbose=1 if param.verbose == 2 else 0,
env=env,
**kw)
elif param.todo == 'apply':
sct_apply_transfo.main(argv=[
'-i', file_src, '-d', file_dest, '-w', file_mat + param.suffix_mat,
'-o', file_out_concat, '-x', param.interp, '-v', '0'
])
# check if output file exists
# Note (from JCA): In the past, i've tried to catch non-zero output from ANTs function (via the 'status' variable),
# but in some OSs, the function can fail while outputing zero. So as a pragmatic approach, I decided to go with
# the "output file checking" approach, which is 100% sensitive.
if not os.path.isfile(file_out_concat):
# printv(output, verbose, 'error')
printv(
'WARNING in ' + os.path.basename(__file__) +
': No output. Maybe related to improper calculation of '
'mutual information. Either the mask you provided is '
'too small, or the subject moved a lot. If you see too '
'many messages like this try with a bigger mask. '
'Using previous transformation for this volume (if it'
'exists).', param.verbose, 'warning')
failed_transfo = 1
# If sagittal, copy header (because ANTs screws it) and add singleton in 3rd dimension (for z-concatenation)
if im_data.orientation[2] in 'LR' and do_registration:
im_out = Image(file_out_concat)
im_out.header = im_data.header
im_out.data = np.expand_dims(im_out.data, 2)
im_out.save(file_out, verbose=0)
# return status of failure
return failed_transfo
def propseg(img_input, options_dict):
"""
:param img_input: source image, to be segmented
:param options_dict: arguments as dictionary
:return: segmented Image
"""
arguments = options_dict
fname_input_data = img_input.absolutepath
fname_data = os.path.abspath(fname_input_data)
contrast_type = arguments.c
contrast_type_conversion = {
't1': 't1',
't2': 't2',
't2s': 't2',
'dwi': 't1'
}
contrast_type_propseg = contrast_type_conversion[contrast_type]
# Starting building the command
cmd = ['isct_propseg', '-t', contrast_type_propseg]
if arguments.o is not None:
fname_out = arguments.o
else:
fname_out = os.path.basename(add_suffix(fname_data, "_seg"))
folder_output = os.path.dirname(fname_out)
cmd += ['-o', folder_output]
if not os.path.isdir(folder_output) and os.path.exists(folder_output):
logger.error("output directory %s is not a valid directory" %
folder_output)
if not os.path.exists(folder_output):
os.makedirs(folder_output)
if arguments.down is not None:
cmd += ["-down", str(arguments.down)]
if arguments.up is not None:
cmd += ["-up", str(arguments.up)]
remove_temp_files = arguments.r
verbose = int(arguments.v)
# Update for propseg binary
if verbose > 0:
cmd += ["-verbose"]
# Output options
if arguments.mesh is not None:
cmd += ["-mesh"]
if arguments.centerline_binary is not None:
cmd += ["-centerline-binary"]
if arguments.CSF is not None:
cmd += ["-CSF"]
if arguments.centerline_coord is not None:
cmd += ["-centerline-coord"]
if arguments.cross is not None:
cmd += ["-cross"]
if arguments.init_tube is not None:
cmd += ["-init-tube"]
if arguments.low_resolution_mesh is not None:
cmd += ["-low-resolution-mesh"]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_nii is not None:
# cmd += ["-detect-nii"]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_png is not None:
# cmd += ["-detect-png"]
# Helping options
use_viewer = None
use_optic = True # enabled by default
init_option = None
rescale_header = arguments.rescale
if arguments.init is not None:
init_option = float(arguments.init)
if init_option < 0:
printv(
'Command-line usage error: ' + str(init_option) +
" is not a valid value for '-init'", 1, 'error')
sys.exit(1)
if arguments.init_centerline is not None:
if str(arguments.init_centerline) == "viewer":
use_viewer = "centerline"
elif str(arguments.init_centerline) == "hough":
use_optic = False
else:
if rescale_header is not 1:
fname_labels_viewer = func_rescale_header(str(
arguments.init_centerline),
rescale_header,
verbose=verbose)
else:
fname_labels_viewer = str(arguments.init_centerline)
cmd += ["-init-centerline", fname_labels_viewer]
use_optic = False
if arguments.init_mask is not None:
if str(arguments.init_mask) == "viewer":
use_viewer = "mask"
else:
if rescale_header is not 1:
fname_labels_viewer = func_rescale_header(
str(arguments.init_mask), rescale_header)
else:
fname_labels_viewer = str(arguments.init_mask)
cmd += ["-init-mask", fname_labels_viewer]
use_optic = False
if arguments.mask_correction is not None:
cmd += ["-mask-correction", str(arguments.mask_correction)]
if arguments.radius is not None:
cmd += ["-radius", str(arguments.radius)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_n is not None:
# cmd += ["-detect-n", str(arguments.detect_n)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_gap is not None:
# cmd += ["-detect-gap", str(arguments.detect_gap)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.init_validation is not None:
# cmd += ["-init-validation"]
if arguments.nbiter is not None:
cmd += ["-nbiter", str(arguments.nbiter)]
if arguments.max_area is not None:
cmd += ["-max-area", str(arguments.max_area)]
if arguments.max_deformation is not None:
cmd += ["-max-deformation", str(arguments.max_deformation)]
if arguments.min_contrast is not None:
cmd += ["-min-contrast", str(arguments.min_contrast)]
if arguments.d is not None:
cmd += ["-d", str(arguments["-d"])]
if arguments.distance_search is not None:
cmd += ["-dsearch", str(arguments.distance_search)]
if arguments.alpha is not None:
cmd += ["-alpha", str(arguments.alpha)]
# check if input image is in 3D. Otherwise itk image reader will cut the 4D image in 3D volumes and only take the first one.
image_input = Image(fname_data)
image_input_rpi = image_input.copy().change_orientation('RPI')
nx, ny, nz, nt, px, py, pz, pt = image_input_rpi.dim
if nt > 1:
printv(
'ERROR: your input image needs to be 3D in order to be segmented.',
1, 'error')
path_data, file_data, ext_data = extract_fname(fname_data)
path_tmp = tmp_create(basename="label_vertebrae")
# rescale header (see issue #1406)
if rescale_header is not 1:
fname_data_propseg = func_rescale_header(fname_data, rescale_header)
else:
fname_data_propseg = fname_data
# add to command
cmd += ['-i', fname_data_propseg]
# if centerline or mask is asked using viewer
if use_viewer:
from spinalcordtoolbox.gui.base import AnatomicalParams
from spinalcordtoolbox.gui.centerline import launch_centerline_dialog
params = AnatomicalParams()
if use_viewer == 'mask':
params.num_points = 3
params.interval_in_mm = 15 # superior-inferior interval between two consecutive labels
params.starting_slice = 'midfovminusinterval'
if use_viewer == 'centerline':
# setting maximum number of points to a reasonable value
params.num_points = 20
params.interval_in_mm = 30
params.starting_slice = 'top'
im_data = Image(fname_data_propseg)
im_mask_viewer = zeros_like(im_data)
# im_mask_viewer.absolutepath = add_suffix(fname_data_propseg, '_labels_viewer')
controller = launch_centerline_dialog(im_data, im_mask_viewer, params)
fname_labels_viewer = add_suffix(fname_data_propseg, '_labels_viewer')
if not controller.saved:
printv(
'The viewer has been closed before entering all manual points. Please try again.',
1, 'error')
sys.exit(1)
# save labels
controller.as_niftii(fname_labels_viewer)
# add mask filename to parameters string
if use_viewer == "centerline":
cmd += ["-init-centerline", fname_labels_viewer]
elif use_viewer == "mask":
cmd += ["-init-mask", fname_labels_viewer]
# If using OptiC
elif use_optic:
image_centerline = optic.detect_centerline(image_input, contrast_type,
verbose)
fname_centerline_optic = os.path.join(path_tmp,
'centerline_optic.nii.gz')
image_centerline.save(fname_centerline_optic)
cmd += ["-init-centerline", fname_centerline_optic]
if init_option is not None:
if init_option > 1:
init_option /= (nz - 1)
cmd += ['-init', str(init_option)]
# enabling centerline extraction by default (needed by check_and_correct_segmentation() )
cmd += ['-centerline-binary']
# run propseg
status, output = run_proc(cmd,
verbose,
raise_exception=False,
is_sct_binary=True)
# check status is not 0
if not status == 0:
printv(
'Automatic cord detection failed. Please initialize using -init-centerline or -init-mask (see help)',
1, 'error')
sys.exit(1)
# build output filename
fname_seg = os.path.join(folder_output, fname_out)
fname_centerline = os.path.join(
folder_output, os.path.basename(add_suffix(fname_data, "_centerline")))
# in case header was rescaled, we need to update the output file names by removing the "_rescaled"
if rescale_header is not 1:
mv(
os.path.join(
folder_output,
add_suffix(os.path.basename(fname_data_propseg), "_seg")),
fname_seg)
mv(
os.path.join(
folder_output,
add_suffix(os.path.basename(fname_data_propseg),
"_centerline")), fname_centerline)
# if user was used, copy the labelled points to the output folder (they will then be scaled back)
if use_viewer:
fname_labels_viewer_new = os.path.join(
folder_output,
os.path.basename(add_suffix(fname_data, "_labels_viewer")))
copy(fname_labels_viewer, fname_labels_viewer_new)
# update variable (used later)
fname_labels_viewer = fname_labels_viewer_new
# check consistency of segmentation
if arguments.correct_seg:
check_and_correct_segmentation(fname_seg,
fname_centerline,
folder_output=folder_output,
threshold_distance=3.0,
remove_temp_files=remove_temp_files,
verbose=verbose)
# copy header from input to segmentation to make sure qform is the same
printv("Copy header input --> output(s) to make sure qform is the same.",
verbose)
list_fname = [fname_seg, fname_centerline]
if use_viewer:
list_fname.append(fname_labels_viewer)
for fname in list_fname:
im = Image(fname)
im.header = image_input.header
im.save(dtype='int8'
) # they are all binary masks hence fine to save as int8
return Image(fname_seg)
def spline(folder_mat, nt, nz, verbose, index_b0=[], graph=0):
printv(
'\n\n\n------------------------------------------------------------------------------',
verbose)
printv('Spline Regularization along T: Smoothing Patient Motion...',
verbose)
file_mat = [[[] for i in range(nz)] for i in range(nt)]
for it in range(nt):
for iz in range(nz):
file_mat[it][iz] = os.path.join(
folder_mat, "mat.T") + str(it) + '_Z' + str(iz) + '.txt'
# Copying the existing Matrices to another folder
old_mat = os.path.join(folder_mat, "old")
try:
os.makedirs(old_mat)
except FileExistsError:
pass
# TODO
for mat in glob.glob(os.path.join(folder_mat, '*.txt')):
copy(mat, old_mat)
printv('\nloading matrices...', verbose)
X = [[[] for i in range(nt)] for i in range(nz)]
Y = [[[] for i in range(nt)] for i in range(nz)]
X_smooth = [[[] for i in range(nt)] for i in range(nz)]
Y_smooth = [[[] for i in range(nt)] for i in range(nz)]
for iz in range(nz):
for it in range(nt):
file = open(file_mat[it][iz])
Matrix = np.loadtxt(file)
file.close()
X[iz][it] = Matrix[0, 3]
Y[iz][it] = Matrix[1, 3]
# Generate motion splines
printv('\nGenerate motion splines...', verbose)
T = np.arange(nt)
if graph:
import pylab as pl
for iz in range(nz):
spline = scipy.interpolate.UnivariateSpline(T,
X[iz][:],
w=None,
bbox=[None, None],
k=3,
s=None)
X_smooth[iz][:] = spline(T)
if graph:
pl.plot(T, X_smooth[iz][:], label='spline_smoothing')
pl.plot(T,
X[iz][:],
marker='*',
linestyle='None',
label='original_val')
if len(index_b0) != 0:
T_b0 = [T[i_b0] for i_b0 in index_b0]
X_b0 = [X[iz][i_b0] for i_b0 in index_b0]
pl.plot(T_b0,
X_b0,
marker='D',
linestyle='None',
color='k',
label='b=0')
pl.title('X')
pl.grid()
pl.legend()
pl.show()
spline = scipy.interpolate.UnivariateSpline(T,
Y[iz][:],
w=None,
bbox=[None, None],
k=3,
s=None)
Y_smooth[iz][:] = spline(T)
if graph:
pl.plot(T, Y_smooth[iz][:], label='spline_smoothing')
pl.plot(T,
Y[iz][:],
marker='*',
linestyle='None',
label='original_val')
if len(index_b0) != 0:
T_b0 = [T[i_b0] for i_b0 in index_b0]
Y_b0 = [Y[iz][i_b0] for i_b0 in index_b0]
pl.plot(T_b0,
Y_b0,
marker='D',
linestyle='None',
color='k',
label='b=0')
pl.title('Y')
pl.grid()
pl.legend()
pl.show()
# Storing the final Matrices
printv('\nStoring the final Matrices...', verbose)
for iz in range(nz):
for it in range(nt):
file = open(file_mat[it][iz])
Matrix = np.loadtxt(file)
file.close()
Matrix[0, 3] = X_smooth[iz][it]
Matrix[1, 3] = Y_smooth[iz][it]
file = open(file_mat[it][iz], 'w')
np.savetxt(file_mat[it][iz],
Matrix,
fmt="%s",
delimiter=' ',
newline='\n')
file.close()
printv('\n...Done. Patient motion has been smoothed', verbose)
printv(
'------------------------------------------------------------------------------\n',
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 main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv if argv else ['--help'])
verbose = arguments.v
set_global_loglevel(verbose=verbose)
fname_input1 = arguments.i
fname_input2 = arguments.d
tmp_dir = tmp_create() # create tmp directory
tmp_dir = os.path.abspath(tmp_dir)
# copy input files to tmp directory
# for fname in [fname_input1, fname_input2]:
copy(fname_input1, tmp_dir)
copy(fname_input2, tmp_dir)
fname_input1 = ''.join(extract_fname(fname_input1)[1:])
fname_input2 = ''.join(extract_fname(fname_input2)[1:])
curdir = os.getcwd()
os.chdir(tmp_dir) # go to tmp directory
if arguments.bin is not None:
fname_input1_bin = add_suffix(fname_input1, '_bin')
run_proc(['sct_maths', '-i', fname_input1, '-bin', '0', '-o', fname_input1_bin])
fname_input1 = fname_input1_bin
fname_input2_bin = add_suffix(fname_input2, '_bin')
run_proc(['sct_maths', '-i', fname_input2, '-bin', '0', '-o', fname_input2_bin])
fname_input2 = fname_input2_bin
# copy header of im_1 to im_2
from spinalcordtoolbox.image import Image
im_1 = Image(fname_input1)
im_2 = Image(fname_input2)
im_2.header = im_1.header
im_2.save()
cmd = ['isct_dice_coefficient', fname_input1, fname_input2]
if vars(arguments)["2d_slices"] is not None:
cmd += ['-2d-slices', str(vars(arguments)["2d_slices"])]
if arguments.b is not None:
bounding_box = arguments.b
cmd += ['-b'] + bounding_box
if arguments.bmax is not None and arguments.bmax == 1:
cmd += ['-bmax']
if arguments.bzmax is not None and arguments.bzmax == 1:
cmd += ['-bzmax']
if arguments.o is not None:
path_output, fname_output, ext = extract_fname(arguments.o)
cmd += ['-o', fname_output + ext]
rm_tmp = bool(arguments.r)
# # Computation of Dice coefficient using Python implementation.
# # commented for now as it does not cover all the feature of isct_dice_coefficient
# #from spinalcordtoolbox.image import Image, compute_dice
# #dice = compute_dice(Image(fname_input1), Image(fname_input2), mode='3d', zboundaries=False)
# #printv('Dice (python-based) = ' + str(dice), verbose)
status, output = run_proc(cmd, verbose, is_sct_binary=True)
os.chdir(curdir) # go back to original directory
# copy output file into original directory
if arguments.o is not None:
copy(os.path.join(tmp_dir, fname_output + ext), os.path.join(path_output, fname_output + ext))
# remove tmp_dir
if rm_tmp:
rmtree(tmp_dir)
printv(output, verbose)
def apply(self):
# Initialization
fname_src = self.input_filename # source image (moving)
list_warp = self.list_warp # list of warping fields
fname_out = self.output_filename # output
fname_dest = self.fname_dest # destination image (fix)
verbose = self.verbose
remove_temp_files = self.remove_temp_files
crop_reference = self.crop # if = 1, put 0 everywhere around warping field, if = 2, real crop
islabel = False
if self.interp == 'label':
islabel = True
self.interp = 'nn'
interp = get_interpolation('isct_antsApplyTransforms', self.interp)
# Parse list of warping fields
printv('\nParse list of warping fields...', verbose)
use_inverse = []
fname_warp_list_invert = []
# list_warp = list_warp.replace(' ', '') # remove spaces
# list_warp = list_warp.split(",") # parse with comma
for idx_warp, path_warp in enumerate(self.list_warp):
# Check if this transformation should be inverted
if path_warp in self.list_warpinv:
use_inverse.append('-i')
# list_warp[idx_warp] = path_warp[1:] # remove '-'
fname_warp_list_invert += [[
use_inverse[idx_warp], list_warp[idx_warp]
]]
else:
use_inverse.append('')
fname_warp_list_invert += [[path_warp]]
path_warp = list_warp[idx_warp]
if path_warp.endswith((".nii", ".nii.gz")) \
and Image(list_warp[idx_warp]).header.get_intent()[0] != 'vector':
raise ValueError(
"Displacement field in {} is invalid: should be encoded"
" in a 5D file with vector intent code"
" (see https://nifti.nimh.nih.gov/pub/dist/src/niftilib/nifti1.h"
.format(path_warp))
# need to check if last warping field is an affine transfo
isLastAffine = False
path_fname, file_fname, ext_fname = extract_fname(
fname_warp_list_invert[-1][-1])
if ext_fname in ['.txt', '.mat']:
isLastAffine = True
# check if destination file is 3d
# check_dim(fname_dest, dim_lst=[3]) # PR 2598: we decided to skip this line.
# N.B. Here we take the inverse of the warp list, because sct_WarpImageMultiTransform concatenates in the reverse order
fname_warp_list_invert.reverse()
fname_warp_list_invert = functools.reduce(lambda x, y: x + y,
fname_warp_list_invert)
# Extract path, file and extension
path_src, file_src, ext_src = extract_fname(fname_src)
path_dest, file_dest, ext_dest = extract_fname(fname_dest)
# Get output folder and file name
if fname_out == '':
path_out = '' # output in user's current directory
file_out = file_src + '_reg'
ext_out = ext_src
fname_out = os.path.join(path_out, file_out + ext_out)
# Get dimensions of data
printv('\nGet dimensions of data...', verbose)
img_src = Image(fname_src)
nx, ny, nz, nt, px, py, pz, pt = img_src.dim
# nx, ny, nz, nt, px, py, pz, pt = get_dimension(fname_src)
printv(
' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' +
str(nt), verbose)
# if 3d
if nt == 1:
# Apply transformation
printv('\nApply transformation...', verbose)
if nz in [0, 1]:
dim = '2'
else:
dim = '3'
# if labels, dilate before resampling
if islabel:
printv("\nDilate labels before warping...")
path_tmp = tmp_create(basename="apply_transfo")
fname_dilated_labels = os.path.join(path_tmp,
"dilated_data.nii")
# dilate points
dilate(Image(fname_src), 4, 'ball').save(fname_dilated_labels)
fname_src = fname_dilated_labels
printv(
"\nApply transformation and resample to destination space...",
verbose)
run_proc([
'isct_antsApplyTransforms', '-d', dim, '-i', fname_src, '-o',
fname_out, '-t'
] + fname_warp_list_invert + ['-r', fname_dest] + interp,
is_sct_binary=True)
# if 4d, loop across the T dimension
else:
if islabel:
raise NotImplementedError
dim = '4'
path_tmp = tmp_create(basename="apply_transfo")
# convert to nifti into temp folder
printv('\nCopying input data to tmp folder and convert to nii...',
verbose)
img_src.save(os.path.join(path_tmp, "data.nii"))
copy(fname_dest, os.path.join(path_tmp, file_dest + ext_dest))
fname_warp_list_tmp = []
for fname_warp in list_warp:
path_warp, file_warp, ext_warp = extract_fname(fname_warp)
copy(fname_warp, os.path.join(path_tmp, file_warp + ext_warp))
fname_warp_list_tmp.append(file_warp + ext_warp)
fname_warp_list_invert_tmp = fname_warp_list_tmp[::-1]
curdir = os.getcwd()
os.chdir(path_tmp)
# split along T dimension
printv('\nSplit along T dimension...', verbose)
im_dat = Image('data.nii')
im_header = im_dat.hdr
data_split_list = sct_image.split_data(im_dat, 3)
for im in data_split_list:
im.save()
# apply transfo
printv('\nApply transformation to each 3D volume...', verbose)
for it in range(nt):
file_data_split = 'data_T' + str(it).zfill(4) + '.nii'
file_data_split_reg = 'data_reg_T' + str(it).zfill(4) + '.nii'
status, output = run_proc([
'isct_antsApplyTransforms',
'-d',
'3',
'-i',
file_data_split,
'-o',
file_data_split_reg,
'-t',
] + fname_warp_list_invert_tmp + [
'-r',
file_dest + ext_dest,
] + interp,
verbose,
is_sct_binary=True)
# Merge files back
printv('\nMerge file back...', verbose)
import glob
path_out, name_out, ext_out = extract_fname(fname_out)
# im_list = [Image(file_name) for file_name in glob.glob('data_reg_T*.nii')]
# concat_data use to take a list of image in input, now takes a list of file names to open the files one by one (see issue #715)
fname_list = glob.glob('data_reg_T*.nii')
fname_list.sort()
im_list = [Image(fname) for fname in fname_list]
im_out = sct_image.concat_data(im_list, 3, im_header['pixdim'])
im_out.save(name_out + ext_out)
os.chdir(curdir)
generate_output_file(os.path.join(path_tmp, name_out + ext_out),
fname_out)
# Delete temporary folder if specified
if remove_temp_files:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp, verbose=verbose)
# Copy affine matrix from destination space to make sure qform/sform are the same
printv(
"Copy affine matrix from destination space to make sure qform/sform are the same.",
verbose)
im_src_reg = Image(fname_out)
im_src_reg.copy_qform_from_ref(Image(fname_dest))
im_src_reg.save(
verbose=0
) # set verbose=0 to avoid warning message about rewriting file
if islabel:
printv(
"\nTake the center of mass of each registered dilated labels..."
)
labeled_img = cubic_to_point(im_src_reg)
labeled_img.save(path=fname_out)
if remove_temp_files:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp, verbose=verbose)
# Crop the resulting image using dimensions from the warping field
warping_field = fname_warp_list_invert[-1]
# If the last transformation is not an affine transfo, we need to compute the matrix space of the concatenated
# warping field
if not isLastAffine and crop_reference in [1, 2]:
printv('Last transformation is not affine.')
if crop_reference in [1, 2]:
# Extract only the first ndim of the warping field
img_warp = Image(warping_field)
if dim == '2':
img_warp_ndim = Image(img_src.data[:, :], hdr=img_warp.hdr)
elif dim in ['3', '4']:
img_warp_ndim = Image(img_src.data[:, :, :],
hdr=img_warp.hdr)
# Set zero to everything outside the warping field
cropper = ImageCropper(Image(fname_out))
cropper.get_bbox_from_ref(img_warp_ndim)
if crop_reference == 1:
printv(
'Cropping strategy is: keep same matrix size, put 0 everywhere around warping field'
)
img_out = cropper.crop(background=0)
elif crop_reference == 2:
printv(
'Cropping strategy is: crop around warping field (the size of warping field will '
'change)')
img_out = cropper.crop()
img_out.save(fname_out)
display_viewer_syntax([fname_dest, fname_out], verbose=verbose)
