def register(src, dest, paramreg, param, i_step_str):
# initiate default parameters of antsRegistration transformation
ants_registration_params = {
'rigid': '',
'affine': '',
'compositeaffine': '',
'similarity': '',
'translation': '',
'bspline': ',10',
'gaussiandisplacementfield': ',3,0',
'bsplinedisplacementfield': ',5,10',
'syn': ',3,0',
'bsplinesyn': ',1,3'
}
output = '' # default output if problem
# display arguments
sct.printv('Registration parameters:', param.verbose)
sct.printv(' type ........... ' + paramreg.steps[i_step_str].type,
param.verbose)
sct.printv(' algo ........... ' + paramreg.steps[i_step_str].algo,
param.verbose)
sct.printv(' slicewise ...... ' + paramreg.steps[i_step_str].slicewise,
param.verbose)
sct.printv(' metric ......... ' + paramreg.steps[i_step_str].metric,
param.verbose)
sct.printv(' iter ........... ' + paramreg.steps[i_step_str].iter,
param.verbose)
sct.printv(' smooth ......... ' + paramreg.steps[i_step_str].smooth,
param.verbose)
sct.printv(' laplacian ...... ' + paramreg.steps[i_step_str].laplacian,
param.verbose)
sct.printv(' shrink ......... ' + paramreg.steps[i_step_str].shrink,
param.verbose)
sct.printv(' gradStep ....... ' + paramreg.steps[i_step_str].gradStep,
param.verbose)
sct.printv(' deformation .... ' + paramreg.steps[i_step_str].deformation,
param.verbose)
sct.printv(' init ........... ' + paramreg.steps[i_step_str].init,
param.verbose)
sct.printv(' poly ........... ' + paramreg.steps[i_step_str].poly,
param.verbose)
sct.printv(' dof ............ ' + paramreg.steps[i_step_str].dof,
param.verbose)
sct.printv(' smoothWarpXY ... ' + paramreg.steps[i_step_str].smoothWarpXY,
param.verbose)
# set metricSize
if paramreg.steps[i_step_str].metric == 'MI':
metricSize = '32' # corresponds to number of bins
else:
metricSize = '4' # corresponds to radius (for CC, MeanSquares...)
# set masking
if param.fname_mask:
fname_mask = 'mask.nii.gz'
masking = ['-x', 'mask.nii.gz']
else:
fname_mask = ''
masking = []
if paramreg.steps[i_step_str].algo == 'slicereg':
# check if user used type=label
if paramreg.steps[i_step_str].type == 'label':
sct.printv(
'\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg',
1, 'error')
else:
# Find the min (and max) z-slice index below which (and above which) slices only have voxels below a given
# threshold.
list_fname = [src, dest]
if not masking == []:
list_fname.append(fname_mask)
zmin_global, zmax_global = 0, 99999 # this is assuming that typical image has less slice than 99999
for fname in list_fname:
im = Image(fname)
zmin, zmax = msct_image.find_zmin_zmax(im, threshold=0.1)
if zmin > zmin_global:
zmin_global = zmin
if zmax < zmax_global:
zmax_global = zmax
# crop images (see issue #293)
src_crop = sct.add_suffix(src, '_crop')
msct_image.spatial_crop(Image(src),
dict(
((2, (zmin_global,
zmax_global)), ))).save(src_crop)
dest_crop = sct.add_suffix(dest, '_crop')
msct_image.spatial_crop(Image(dest),
dict(((2,
(zmin_global,
zmax_global)), ))).save(dest_crop)
# update variables
src = src_crop
dest = dest_crop
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
# estimate transfo
# TODO fixup isct_ants* parsers
cmd = [
'isct_antsSliceRegularizedRegistration',
'-t',
'Translation[' + paramreg.steps[i_step_str].gradStep + ']',
'-m',
paramreg.steps[i_step_str].metric + '[' + dest + ',' + src +
',1,' + metricSize + ',Regular,0.2]',
'-p',
paramreg.steps[i_step_str].poly,
'-i',
paramreg.steps[i_step_str].iter,
'-f',
paramreg.steps[i_step_str].shrink,
'-s',
paramreg.steps[i_step_str].smooth,
'-v',
'1', # verbose (verbose=2 does not exist, so we force it to 1)
'-o',
'[step' + i_step_str + ',' + scr_regStep +
']', # here the warp name is stage10 because
# antsSliceReg add "Warp"
] + masking
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
# run command
status, output = sct.run(cmd, param.verbose)
# ANTS 3d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params \
and paramreg.steps[i_step_str].slicewise == '0':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
# Pad the destination image (because ants doesn't deform the extremities)
# N.B. no need to pad if iter = 0
if not paramreg.steps[i_step_str].iter == '0':
dest_pad = sct.add_suffix(dest, '_pad')
sct.run([
'sct_image', '-i', dest, '-o', dest_pad, '-pad',
'0,0,' + str(param.padding)
])
dest = dest_pad
# apply Laplacian filter
if not paramreg.steps[i_step_str].laplacian == '0':
sct.printv('\nApply Laplacian filter', param.verbose)
sct.run([
'sct_maths', '-i', src, '-laplacian',
paramreg.steps[i_step_str].laplacian + ',' +
paramreg.steps[i_step_str].laplacian + ',0', '-o',
sct.add_suffix(src, '_laplacian')
])
sct.run([
'sct_maths', '-i', dest, '-laplacian',
paramreg.steps[i_step_str].laplacian + ',' +
paramreg.steps[i_step_str].laplacian + ',0', '-o',
sct.add_suffix(dest, '_laplacian')
])
src = sct.add_suffix(src, '_laplacian')
dest = sct.add_suffix(dest, '_laplacian')
# Estimate transformation
sct.printv('\nEstimate transformation', param.verbose)
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
# TODO fixup isct_ants* parsers
cmd = [
'isct_antsRegistration',
'--dimensionality',
'3',
'--transform',
paramreg.steps[i_step_str].algo + '[' +
paramreg.steps[i_step_str].gradStep + ants_registration_params[
paramreg.steps[i_step_str].algo.lower()] + ']',
'--metric',
paramreg.steps[i_step_str].metric + '[' + dest + ',' + src +
',1,' + metricSize + ']',
'--convergence',
paramreg.steps[i_step_str].iter,
'--shrink-factors',
paramreg.steps[i_step_str].shrink,
'--smoothing-sigmas',
paramreg.steps[i_step_str].smooth + 'mm',
'--restrict-deformation',
paramreg.steps[i_step_str].deformation,
'--output',
'[step' + i_step_str + ',' + scr_regStep + ']',
'--interpolation',
'BSpline[3]',
'--verbose',
'1',
] + masking
# add init translation
if not paramreg.steps[i_step_str].init == '':
init_dict = {
'geometric': '0',
'centermass': '1',
'origin': '2'
}
cmd += [
'-r', '[' + dest + ',' + src + ',' +
init_dict[paramreg.steps[i_step_str].init] + ']'
]
# run command
status, output = sct.run(cmd, param.verbose)
# get appropriate file name for transformation
if paramreg.steps[i_step_str].algo in [
'rigid', 'affine', 'translation'
]:
warp_forward_out = 'step' + i_step_str + '0GenericAffine.mat'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.mat'
else:
warp_forward_out = 'step' + i_step_str + '0Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + '0InverseWarp.nii.gz'
# ANTS 2d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params \
and paramreg.steps[i_step_str].slicewise == '1':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
from msct_register import register_slicewise
# if shrink!=1, force it to be 1 (otherwise, it generates a wrong 3d warping field). TODO: fix that!
if not paramreg.steps[i_step_str].shrink == '1':
sct.printv(
'\nWARNING: when using slicewise with SyN or BSplineSyN, shrink factor needs to be one. '
'Forcing shrink=1.', 1, 'warning')
paramreg.steps[i_step_str].shrink = '1'
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
register_slicewise(
src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
remove_temp_files=param.remove_temp_files,
verbose=param.verbose)
# slice-wise transfo
elif paramreg.steps[i_step_str].algo in [
'centermass', 'centermassrot', 'columnwise'
]:
# if type=im, sends warning
if paramreg.steps[i_step_str].type == 'im':
sct.printv(
'\nWARNING: algo ' + paramreg.steps[i_step_str].algo +
' should be used with type=seg.\n', 1, 'warning')
# if type=label, exit with error
elif paramreg.steps[i_step_str].type == 'label':
sct.printv(
'\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg',
1, 'error')
# check if user provided a mask-- if so, inform it will be ignored
if not fname_mask == '':
sct.printv(
'\nWARNING: algo ' + paramreg.steps[i_step_str].algo +
' will ignore the provided mask.\n', 1, 'warning')
# smooth data
if not paramreg.steps[i_step_str].smooth == '0':
sct.printv('\nSmooth data', param.verbose)
sct.run([
'sct_maths', '-i', src, '-smooth',
paramreg.steps[i_step_str].smooth + ',' +
paramreg.steps[i_step_str].smooth + ',0', '-o',
sct.add_suffix(src, '_smooth')
])
sct.run([
'sct_maths', '-i', dest, '-smooth',
paramreg.steps[i_step_str].smooth + ',' +
paramreg.steps[i_step_str].smooth + ',0', '-o',
sct.add_suffix(dest, '_smooth')
])
src = sct.add_suffix(src, '_smooth')
dest = sct.add_suffix(dest, '_smooth')
from msct_register import register_slicewise
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
remove_temp_files=param.remove_temp_files,
verbose=param.verbose)
else:
sct.printv(
'\nERROR: algo ' + paramreg.steps[i_step_str].algo +
' does not exist. Exit program\n', 1, 'error')
# landmark-based registration
if paramreg.steps[i_step_str].type in ['label']:
# check if user specified ilabel and dlabel
# TODO
warp_forward_out = 'step' + i_step_str + '0GenericAffine.txt'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.txt'
from msct_register_landmarks import register_landmarks
register_landmarks(src,
dest,
paramreg.steps[i_step_str].dof,
fname_affine=warp_forward_out,
verbose=param.verbose)
if not os.path.isfile(warp_forward_out):
# no forward warping field for rigid and affine
sct.printv(
'\nERROR: file ' + warp_forward_out +
' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
elif not os.path.isfile(warp_inverse_out) and \
paramreg.steps[i_step_str].algo not in ['rigid', 'affine', 'translation'] and \
paramreg.steps[i_step_str].type not in ['label']:
# no inverse warping field for rigid and affine
sct.printv(
'\nERROR: file ' + warp_inverse_out +
' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
else:
# rename warping fields
if (paramreg.steps[i_step_str].algo.lower()
in ['rigid', 'affine', 'translation']
and paramreg.steps[i_step_str].slicewise == '0'):
# if ANTs is used with affine/rigid --> outputs .mat file
warp_forward = 'warp_forward_' + i_step_str + '.mat'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.mat'
elif paramreg.steps[i_step_str].type in ['label']:
# if label-based registration is used --> outputs .txt file
warp_forward = 'warp_forward_' + i_step_str + '.txt'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.txt'
else:
warp_forward = 'warp_forward_' + i_step_str + '.nii.gz'
warp_inverse = 'warp_inverse_' + i_step_str + '.nii.gz'
os.rename(warp_forward_out, warp_forward)
os.rename(warp_inverse_out, warp_inverse)
return warp_forward, warp_inverse
def register(src, dest, paramreg, param, i_step_str):
# initiate default parameters of antsRegistration transformation
ants_registration_params = {
'rigid': '',
'affine': '',
'compositeaffine': '',
'similarity': '',
'translation': '',
'bspline': ',10',
'gaussiandisplacementfield': ',3,0',
'bsplinedisplacementfield': ',5,10',
'syn': ',3,0',
'bsplinesyn': ',1,3'
}
output = '' # default output if problem
# display arguments
sct.printv('Registration parameters:', param.verbose)
sct.printv(' type ........... ' + paramreg.steps[i_step_str].type,
param.verbose)
sct.printv(' algo ........... ' + paramreg.steps[i_step_str].algo,
param.verbose)
sct.printv(' slicewise ...... ' + paramreg.steps[i_step_str].slicewise,
param.verbose)
sct.printv(' metric ......... ' + paramreg.steps[i_step_str].metric,
param.verbose)
sct.printv(' iter ........... ' + paramreg.steps[i_step_str].iter,
param.verbose)
sct.printv(' smooth ......... ' + paramreg.steps[i_step_str].smooth,
param.verbose)
sct.printv(' laplacian ...... ' + paramreg.steps[i_step_str].laplacian,
param.verbose)
sct.printv(' shrink ......... ' + paramreg.steps[i_step_str].shrink,
param.verbose)
sct.printv(' gradStep ....... ' + paramreg.steps[i_step_str].gradStep,
param.verbose)
sct.printv(' deformation .... ' + paramreg.steps[i_step_str].deformation,
param.verbose)
sct.printv(' init ........... ' + paramreg.steps[i_step_str].init,
param.verbose)
sct.printv(' poly ........... ' + paramreg.steps[i_step_str].poly,
param.verbose)
sct.printv(' dof ............ ' + paramreg.steps[i_step_str].dof,
param.verbose)
sct.printv(' smoothWarpXY ... ' + paramreg.steps[i_step_str].smoothWarpXY,
param.verbose)
# set metricSize
if paramreg.steps[i_step_str].metric == 'MI':
metricSize = '32' # corresponds to number of bins
else:
metricSize = '4' # corresponds to radius (for CC, MeanSquares...)
# set masking
if param.fname_mask:
fname_mask = 'mask.nii.gz'
masking = '-x mask.nii.gz'
else:
fname_mask = ''
masking = ''
if paramreg.steps[i_step_str].algo == 'slicereg':
# check if user used type=label
if paramreg.steps[i_step_str].type == 'label':
sct.printv(
'\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg',
1, 'error')
else:
from msct_image import find_zmin_zmax
# threshold images (otherwise, automatic crop does not work -- see issue #293)
src_th = sct.add_suffix(src, '_th')
from msct_image import Image
nii = Image(src)
data = nii.data
data[data < 0.1] = 0
nii.data = data
nii.setFileName(src_th)
nii.save()
# sct.run(fsloutput+'fslmaths '+src+' -thr 0.1 '+src_th, param.verbose)
dest_th = sct.add_suffix(dest, '_th')
nii = Image(dest)
data = nii.data
data[data < 0.1] = 0
nii.data = data
nii.setFileName(dest_th)
nii.save()
# sct.run(fsloutput+'fslmaths '+dest+' -thr 0.1 '+dest_th, param.verbose)
# find zmin and zmax
zmin_src, zmax_src = find_zmin_zmax(src_th)
zmin_dest, zmax_dest = find_zmin_zmax(dest_th)
zmin_total = max([zmin_src, zmin_dest])
zmax_total = min([zmax_src, zmax_dest])
# crop data
src_crop = sct.add_suffix(src, '_crop')
sct.run(
'sct_crop_image -i ' + src + ' -o ' + src_crop +
' -dim 2 -start ' + str(zmin_total) + ' -end ' +
str(zmax_total), param.verbose)
dest_crop = sct.add_suffix(dest, '_crop')
sct.run(
'sct_crop_image -i ' + dest + ' -o ' + dest_crop +
' -dim 2 -start ' + str(zmin_total) + ' -end ' +
str(zmax_total), param.verbose)
# update variables
src = src_crop
dest = dest_crop
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
# estimate transfo
cmd = (
'isct_antsSliceRegularizedRegistration '
'-t Translation[' + paramreg.steps[i_step_str].gradStep + '] '
'-m ' + paramreg.steps[i_step_str].metric + '[' + dest + ',' +
src + ',1,' + metricSize + ',Regular,0.2] '
'-p ' + paramreg.steps[i_step_str].poly + ' '
'-i ' + paramreg.steps[i_step_str].iter + ' '
'-f ' + paramreg.steps[i_step_str].shrink + ' '
'-s ' + paramreg.steps[i_step_str].smooth + ' '
'-v 1 ' # verbose (verbose=2 does not exist, so we force it to 1)
'-o [step' + i_step_str + ',' + scr_regStep +
'] ' # here the warp name is stage10 because antsSliceReg add "Warp"
+ masking)
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
# run command
status, output = sct.run(cmd, param.verbose)
# ANTS 3d
elif paramreg.steps[i_step_str].algo.lower(
) in ants_registration_params and paramreg.steps[
i_step_str].slicewise == '0':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
# Pad the destination image (because ants doesn't deform the extremities)
# N.B. no need to pad if iter = 0
if not paramreg.steps[i_step_str].iter == '0':
dest_pad = sct.add_suffix(dest, '_pad')
sct.run('sct_image -i ' + dest + ' -o ' + dest_pad +
' -pad 0,0,' + str(param.padding))
dest = dest_pad
# apply Laplacian filter
if not paramreg.steps[i_step_str].laplacian == '0':
sct.printv('\nApply Laplacian filter', param.verbose)
sct.run('sct_maths -i ' + src + ' -laplacian ' +
paramreg.steps[i_step_str].laplacian + ',' +
paramreg.steps[i_step_str].laplacian + ',0 -o ' +
sct.add_suffix(src, '_laplacian'))
sct.run('sct_maths -i ' + dest + ' -laplacian ' +
paramreg.steps[i_step_str].laplacian + ',' +
paramreg.steps[i_step_str].laplacian + ',0 -o ' +
sct.add_suffix(dest, '_laplacian'))
src = sct.add_suffix(src, '_laplacian')
dest = sct.add_suffix(dest, '_laplacian')
# Estimate transformation
sct.printv('\nEstimate transformation', param.verbose)
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
cmd = ('isct_antsRegistration '
'--dimensionality 3 '
'--transform ' + paramreg.steps[i_step_str].algo + '[' +
paramreg.steps[i_step_str].gradStep +
ants_registration_params[
paramreg.steps[i_step_str].algo.lower()] + '] '
'--metric ' + paramreg.steps[i_step_str].metric + '[' +
dest + ',' + src + ',1,' + metricSize + '] '
'--convergence ' + paramreg.steps[i_step_str].iter + ' '
'--shrink-factors ' + paramreg.steps[i_step_str].shrink +
' '
'--smoothing-sigmas ' + paramreg.steps[i_step_str].smooth +
'mm '
'--restrict-deformation ' +
paramreg.steps[i_step_str].deformation + ' '
'--output [step' + i_step_str + ',' + scr_regStep + '] '
'--interpolation BSpline[3] '
'--verbose 1 ' + masking)
# add init translation
if not paramreg.steps[i_step_str].init == '':
init_dict = {
'geometric': '0',
'centermass': '1',
'origin': '2'
}
cmd += ' -r [' + dest + ',' + src + ',' + init_dict[
paramreg.steps[i_step_str].init] + ']'
# run command
status, output = sct.run(cmd, param.verbose)
# get appropriate file name for transformation
if paramreg.steps[i_step_str].algo in [
'rigid', 'affine', 'translation'
]:
warp_forward_out = 'step' + i_step_str + '0GenericAffine.mat'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.mat'
else:
warp_forward_out = 'step' + i_step_str + '0Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + '0InverseWarp.nii.gz'
# ANTS 2d
elif paramreg.steps[i_step_str].algo.lower(
) in ants_registration_params and paramreg.steps[
i_step_str].slicewise == '1':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
from msct_register import register_slicewise
# if shrink!=1, force it to be 1 (otherwise, it generates a wrong 3d warping field). TODO: fix that!
if not paramreg.steps[i_step_str].shrink == '1':
sct.printv(
'\nWARNING: when using slicewise with SyN or BSplineSyN, shrink factor needs to be one. Forcing shrink=1.',
1, 'warning')
paramreg.steps[i_step_str].shrink = '1'
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
register_slicewise(
src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
path_qc=param.path_qc,
verbose=param.verbose)
# slice-wise transfo
elif paramreg.steps[i_step_str].algo in [
'centermass', 'centermassrot', 'columnwise'
]:
# if type=im, sends warning
if paramreg.steps[i_step_str].type == 'im':
sct.printv(
'\nWARNING: algo ' + paramreg.steps[i_step_str].algo +
' should be used with type=seg.\n', 1, 'warning')
# if type=label, exit with error
elif paramreg.steps[i_step_str].type == 'label':
sct.printv(
'\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg',
1, 'error')
# check if user provided a mask-- if so, inform it will be ignored
if not fname_mask == '':
sct.printv(
'\nWARNING: algo ' + paramreg.steps[i_step_str].algo +
' will ignore the provided mask.\n', 1, 'warning')
# smooth data
if not paramreg.steps[i_step_str].smooth == '0':
sct.printv('\nSmooth data', param.verbose)
sct.run('sct_maths -i ' + src + ' -smooth ' +
paramreg.steps[i_step_str].smooth + ',' +
paramreg.steps[i_step_str].smooth + ',0 -o ' +
sct.add_suffix(src, '_smooth'))
sct.run('sct_maths -i ' + dest + ' -smooth ' +
paramreg.steps[i_step_str].smooth + ',' +
paramreg.steps[i_step_str].smooth + ',0 -o ' +
sct.add_suffix(dest, '_smooth'))
src = sct.add_suffix(src, '_smooth')
dest = sct.add_suffix(dest, '_smooth')
from msct_register import register_slicewise
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
path_qc=param.path_qc,
verbose=param.verbose)
else:
sct.printv(
'\nERROR: algo ' + paramreg.steps[i_step_str].algo +
' does not exist. Exit program\n', 1, 'error')
# landmark-based registration
if paramreg.steps[i_step_str].type in ['label']:
# check if user specified ilabel and dlabel
# TODO
warp_forward_out = 'step' + i_step_str + '0GenericAffine.txt'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.txt'
from msct_register_landmarks import register_landmarks
register_landmarks(src,
dest,
paramreg.steps[i_step_str].dof,
fname_affine=warp_forward_out,
verbose=param.verbose,
path_qc=param.path_qc)
if not os.path.isfile(warp_forward_out):
# no forward warping field for rigid and affine
sct.printv(
'\nERROR: file ' + warp_forward_out +
' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
elif not os.path.isfile(
warp_inverse_out) and paramreg.steps[i_step_str].algo not in [
'rigid', 'affine', 'translation'
] and paramreg.steps[i_step_str].type not in ['label']:
# no inverse warping field for rigid and affine
sct.printv(
'\nERROR: file ' + warp_inverse_out +
' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
else:
# rename warping fields
if (paramreg.steps[i_step_str].algo.lower()
in ['rigid', 'affine', 'translation']
and paramreg.steps[i_step_str].slicewise == '0'):
# if ANTs is used with affine/rigid --> outputs .mat file
warp_forward = 'warp_forward_' + i_step_str + '.mat'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.mat'
elif paramreg.steps[i_step_str].type in ['label']:
# if label-based registration is used --> outputs .txt file
warp_forward = 'warp_forward_' + i_step_str + '.txt'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.txt'
else:
warp_forward = 'warp_forward_' + i_step_str + '.nii.gz'
warp_inverse = 'warp_inverse_' + i_step_str + '.nii.gz'
os.rename(warp_forward_out, warp_forward)
os.rename(warp_inverse_out, warp_inverse)
return warp_forward, warp_inverse
def main():
parser = get_parser()
param = Param()
args = sys.argv[1:]
arguments = parser.parse(args)
# get arguments
fname_data = arguments['-i']
fname_seg = arguments['-s']
fname_landmarks = arguments['-l']
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
path_template = sct.slash_at_the_end(arguments['-t'], 1)
contrast_template = arguments['-c']
ref = arguments['-ref']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments['-v'])
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
if '-param-straighten' in arguments:
param.param_straighten = arguments['-param-straighten']
# if '-cpu-nb' in arguments:
# arg_cpu = ' -cpu-nb '+str(arguments['-cpu-nb'])
# else:
# arg_cpu = ''
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
# file_template_label = param.file_template_label
zsubsample = param.zsubsample
# smoothing_sigma = param.smoothing_sigma
# retrieve template file names
from sct_warp_template import get_file_label
file_template_vertebral_labeling = get_file_label(path_template + 'template/', 'vertebral')
file_template = get_file_label(path_template + 'template/', contrast_template.upper() + '-weighted')
file_template_seg = get_file_label(path_template + 'template/', 'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = path_template + 'template/' + file_template
fname_template_vertebral_labeling = path_template + 'template/' + file_template_vertebral_labeling
fname_template_seg = path_template + 'template/' + file_template_seg
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
# print arguments
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: ' + fname_data, verbose)
sct.printv(' Landmarks: ' + fname_landmarks, verbose)
sct.printv(' Segmentation: ' + fname_seg, verbose)
sct.printv(' Path template: ' + path_template, verbose)
sct.printv(' Remove temp files: ' + str(remove_temp_files), verbose)
# create QC folder
sct.create_folder(param.path_qc)
# check if data, segmentation and landmarks are in the same space
# JULIEN 2017-04-25: removed because of issue #1168
# sct.printv('\nCheck if data, segmentation and landmarks are in the same space...')
# if not sct.check_if_same_space(fname_data, fname_seg):
# sct.printv('ERROR: Data image and segmentation are not in the same space. Please check space and orientation of your files', verbose, 'error')
# if not sct.check_if_same_space(fname_data, fname_landmarks):
# sct.printv('ERROR: Data image and landmarks are not in the same space. Please check space and orientation of your files', verbose, 'error')
# check input labels
labels = check_labels(fname_landmarks)
# create temporary folder
path_tmp = sct.tmp_create(verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
sct.run('sct_convert -i ' + fname_data + ' -o ' + path_tmp + ftmp_data)
sct.run('sct_convert -i ' + fname_seg + ' -o ' + path_tmp + ftmp_seg)
sct.run('sct_convert -i ' + fname_landmarks + ' -o ' + path_tmp + ftmp_label)
sct.run('sct_convert -i ' + fname_template + ' -o ' + path_tmp + ftmp_template)
sct.run('sct_convert -i ' + fname_template_seg + ' -o ' + path_tmp + ftmp_template_seg)
# sct.run('sct_convert -i '+fname_template_label+' -o '+path_tmp+ftmp_template_label)
# go to tmp folder
os.chdir(path_tmp)
# copy header of anat to segmentation (issue #1168)
# from sct_image import copy_header
# im_data = Image(ftmp_data)
# im_seg = Image(ftmp_seg)
# copy_header(im_data, im_seg)
# im_seg.save()
# im_label = Image(ftmp_label)
# copy_header(im_data, im_label)
# im_label.save()
# Generate labels from template vertebral labeling
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
sct.run('sct_label_utils -i ' + fname_template_vertebral_labeling + ' -vert-body 0 -o ' + ftmp_template_label)
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
sct.run('sct_maths -i seg.nii.gz -bin 0.5 -o seg.nii.gz')
# smooth segmentation (jcohenadad, issue #613)
# sct.printv('\nSmooth segmentation...', verbose)
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 1.5 -o '+add_suffix(ftmp_seg, '_smooth'))
# jcohenadad: updated 2016-06-16: DO NOT smooth the seg anymore. Issue #
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 0 -o '+add_suffix(ftmp_seg, '_smooth'))
# ftmp_seg = add_suffix(ftmp_seg, '_smooth')
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
sct.run('sct_resample -i ' + ftmp_data + ' -mm 1.0x1.0x1.0 -x linear -o ' + add_suffix(ftmp_data, '_1mm'))
ftmp_data = add_suffix(ftmp_data, '_1mm')
sct.run('sct_resample -i ' + ftmp_seg + ' -mm 1.0x1.0x1.0 -x linear -o ' + add_suffix(ftmp_seg, '_1mm'))
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling with neighrest neighbour can make them disappear. Therefore a more clever approach is required.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i ' + ftmp_data + ' -setorient RPI -o ' + add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i ' + ftmp_seg + ' -setorient RPI -o ' + add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i ' + ftmp_label + ' -setorient RPI -o ' + add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# get landmarks in native space
# crop segmentation
# output: segmentation_rpi_crop.nii.gz
status_crop, output_crop = sct.run('sct_crop_image -i ' + ftmp_seg + ' -o ' + add_suffix(ftmp_seg, '_crop') + ' -dim 2 -bzmax', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_crop')
cropping_slices = output_crop.split('Dimension 2: ')[1].split('\n')[0].split(' ')
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
if os.path.isfile('../warp_curve2straight.nii.gz') and os.path.isfile('../warp_straight2curve.nii.gz') and os.path.isfile('../straight_ref.nii.gz'):
# if they exist, copy them into current folder
sct.printv('WARNING: Straightening was already run previously. Copying warping fields...', verbose, 'warning')
shutil.copy('../warp_curve2straight.nii.gz', 'warp_curve2straight.nii.gz')
shutil.copy('../warp_straight2curve.nii.gz', 'warp_straight2curve.nii.gz')
shutil.copy('../straight_ref.nii.gz', 'straight_ref.nii.gz')
# apply straightening
sct.run('sct_apply_transfo -i ' + ftmp_seg + ' -w warp_curve2straight.nii.gz -d straight_ref.nii.gz -o ' + add_suffix(ftmp_seg, '_straight'))
else:
sct.run('sct_straighten_spinalcord -i ' + ftmp_seg + ' -s ' + ftmp_seg + ' -o ' + add_suffix(ftmp_seg, '_straight') + ' -qc 0 -r 0 -v ' + str(verbose), verbose)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
sct.run('sct_concat_transfo -w warp_straight2curve.nii.gz -d ' + ftmp_data + ' -o warp_straight2curve.nii.gz')
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i ' + ftmp_template_label + ' -o ' + ftmp_template_label + ' -remove ' + ftmp_label)
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct.run('sct_maths -i ' + ftmp_label + ' -o ' + add_suffix(ftmp_label, '_dilate') + ' -dilate 3')
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run('sct_apply_transfo -i ' + ftmp_label + ' -o ' + add_suffix(ftmp_label, '_straight') + ' -d ' + add_suffix(ftmp_seg, '_straight') + ' -w warp_curve2straight.nii.gz -x nn')
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof, fname_affine='straight2templateAffine.txt', verbose=verbose)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt -d template.nii -o warp_curve2straightAffine.nii.gz')
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run('sct_apply_transfo -i ' + ftmp_data + ' -o ' + add_suffix(ftmp_data, '_straightAffine') + ' -d ' + ftmp_template + ' -w warp_curve2straightAffine.nii.gz')
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run('sct_apply_transfo -i ' + ftmp_seg + ' -o ' + add_suffix(ftmp_seg, '_straightAffine') + ' -d ' + ftmp_template + ' -w warp_curve2straightAffine.nii.gz -x linear')
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(round(np.min(points_straight))), int(round(np.max(points_straight)))
sct.run('sct_crop_image -i ' + ftmp_seg + ' -start ' + str(min_point) + ' -end ' + str(max_point) + ' -dim 2 -b 0 -o ' + add_suffix(ftmp_seg, '_black'))
ftmp_seg = add_suffix(ftmp_seg, '_black')
"""
# binarize
sct.printv('\nBinarize segmentation...', verbose)
sct.run('sct_maths -i ' + ftmp_seg + ' -bin 0.5 -o ' + add_suffix(ftmp_seg, '_bin'))
ftmp_seg = add_suffix(ftmp_seg, '_bin')
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = find_zmin_zmax(ftmp_seg)
# crop template in z-direction (for faster processing)
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
sct.run('sct_crop_image -i ' + ftmp_template + ' -o ' + add_suffix(ftmp_template, '_crop') + ' -dim 2 -start ' + str(zmin_template) + ' -end ' + str(zmax_template))
ftmp_template = add_suffix(ftmp_template, '_crop')
sct.run('sct_crop_image -i ' + ftmp_template_seg + ' -o ' + add_suffix(ftmp_template_seg, '_crop') + ' -dim 2 -start ' + str(zmin_template) + ' -end ' + str(zmax_template))
ftmp_template_seg = add_suffix(ftmp_template_seg, '_crop')
sct.run('sct_crop_image -i ' + ftmp_data + ' -o ' + add_suffix(ftmp_data, '_crop') + ' -dim 2 -start ' + str(zmin_template) + ' -end ' + str(zmax_template))
ftmp_data = add_suffix(ftmp_data, '_crop')
sct.run('sct_crop_image -i ' + ftmp_seg + ' -o ' + add_suffix(ftmp_seg, '_crop') + ' -dim 2 -start ' + str(zmin_template) + ' -end ' + str(zmax_template))
ftmp_seg = add_suffix(ftmp_seg, '_crop')
# sub-sample in z-direction
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run('sct_resample -i ' + ftmp_template + ' -o ' + add_suffix(ftmp_template, '_sub') + ' -f 1x1x' + zsubsample, verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run('sct_resample -i ' + ftmp_template_seg + ' -o ' + add_suffix(ftmp_template_seg, '_sub') + ' -f 1x1x' + zsubsample, verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run('sct_resample -i ' + ftmp_data + ' -o ' + add_suffix(ftmp_data, '_sub') + ' -f 1x1x' + zsubsample, verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run('sct_resample -i ' + ftmp_seg + ' -o ' + add_suffix(ftmp_seg, '_sub') + ' -f 1x1x' + zsubsample, verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+sct.add_suffix(src, '_reg')+' -x '+interp_step, verbose)
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i ' + src + ' -d ' + dest + ' -w ' + ','.join(warp_forward) + ' -o ' + add_suffix(src, '_regStep' + str(i_step - 1)) + ' -x ' + interp_step, verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straightAffine.nii.gz,' + ','.join(warp_forward) + ' -d template.nii -o warp_anat2template.nii.gz', verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
sct.run('sct_concat_transfo -w ' + ','.join(warp_inverse) + ',-straight2templateAffine.txt,warp_straight2curve.nii.gz -d data.nii -o warp_template2anat.nii.gz', verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i ' + ftmp_data + ' -setorient RPI -o ' + add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i ' + ftmp_seg + ' -setorient RPI -o ' + add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i ' + ftmp_label + ' -setorient RPI -o ' + add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i ' + ftmp_template_label + ' -o ' + ftmp_template_label + ' -remove ' + ftmp_label)
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x), int(new_label.y), int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.setFileName('label_rpi_modif.nii.gz')
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc=param.path_qc)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i ' + src + ' -d ' + dest + ' -w ' + ','.join(warp_forward) + ' -o ' + add_suffix(src, '_regStep' + str(i_step - 1)) + ' -x ' + interp_step, verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct.run('sct_concat_transfo -w ' + ','.join(warp_forward) + ' -d data.nii -o warp_template2anat.nii.gz', verbose)
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct.run('sct_concat_transfo -w ' + ','.join(warp_inverse) + ' -d template.nii -o warp_anat2template.nii.gz', verbose)
# Apply warping fields to anat and template
sct.run('sct_apply_transfo -i template.nii -o template2anat.nii.gz -d data.nii -w warp_template2anat.nii.gz -crop 1', verbose)
sct.run('sct_apply_transfo -i data.nii -o anat2template.nii.gz -d template.nii -w warp_anat2template.nii.gz -crop 1', verbose)
# come back to parent folder
os.chdir('..')
# Generate output files
sct.printv('\nGenerate output files...', verbose)
sct.generate_output_file(path_tmp + 'warp_template2anat.nii.gz', path_output + 'warp_template2anat.nii.gz', verbose)
sct.generate_output_file(path_tmp + 'warp_anat2template.nii.gz', path_output + 'warp_anat2template.nii.gz', verbose)
sct.generate_output_file(path_tmp + 'template2anat.nii.gz', path_output + 'template2anat' + ext_data, verbose)
sct.generate_output_file(path_tmp + 'anat2template.nii.gz', path_output + 'anat2template' + ext_data, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(path_tmp + 'warp_curve2straight.nii.gz', path_output + 'warp_curve2straight.nii.gz', verbose)
sct.generate_output_file(path_tmp + 'warp_straight2curve.nii.gz', path_output + 'warp_straight2curve.nii.gz', verbose)
sct.generate_output_file(path_tmp + 'straight_ref.nii.gz', path_output + 'straight_ref.nii.gz', verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.run('rm -rf ' + path_tmp)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(round(elapsed_time))) + 's', verbose)
if '-qc' in arguments and not arguments.get('-noqc', False):
qc_path = arguments['-qc']
import spinalcordtoolbox.reports.qc as qc
import spinalcordtoolbox.reports.slice as qcslice
qc_param = qc.Params(fname_data, 'sct_register_to_template', args, 'Sagittal', qc_path)
report = qc.QcReport(qc_param, '')
@qc.QcImage(report, 'none', [qc.QcImage.no_seg_seg])
def test(qslice):
return qslice.single()
fname_template2anat = path_output + 'template2anat' + ext_data
test(qcslice.SagittalTemplate2Anat(Image(fname_data), Image(fname_template2anat), Image(fname_seg)))
sct.printv('Sucessfully generate the QC results in %s' % qc_param.qc_results)
sct.printv('Use the following command to see the results in a browser')
sct.printv('sct_qc -folder %s' % qc_path, type='info')
# to view results
sct.printv('\nTo view results, type:', verbose)
sct.printv('fslview ' + fname_data + ' ' + path_output + 'template2anat -b 0,4000 &', verbose, 'info')
sct.printv('fslview ' + fname_template + ' -b 0,5000 ' + path_output + 'anat2template &\n', verbose, 'info')
def register(src, dest, paramreg, param, i_step_str):
# initiate default parameters of antsRegistration transformation
ants_registration_params = {'rigid': '', 'affine': '', 'compositeaffine': '', 'similarity': '', 'translation': '',
'bspline': ',10', 'gaussiandisplacementfield': ',3,0',
'bsplinedisplacementfield': ',5,10', 'syn': ',3,0', 'bsplinesyn': ',1,3'}
output = '' # default output if problem
# display arguments
sct.printv('Registration parameters:', param.verbose)
sct.printv(' type ........... '+paramreg.steps[i_step_str].type, param.verbose)
sct.printv(' algo ........... '+paramreg.steps[i_step_str].algo, param.verbose)
sct.printv(' slicewise ...... '+paramreg.steps[i_step_str].slicewise, param.verbose)
sct.printv(' metric ......... '+paramreg.steps[i_step_str].metric, param.verbose)
sct.printv(' iter ........... '+paramreg.steps[i_step_str].iter, param.verbose)
sct.printv(' smooth ......... '+paramreg.steps[i_step_str].smooth, param.verbose)
sct.printv(' laplacian ...... '+paramreg.steps[i_step_str].laplacian, param.verbose)
sct.printv(' shrink ......... '+paramreg.steps[i_step_str].shrink, param.verbose)
sct.printv(' gradStep ....... '+paramreg.steps[i_step_str].gradStep, param.verbose)
sct.printv(' init ........... '+paramreg.steps[i_step_str].init, param.verbose)
sct.printv(' poly ........... '+paramreg.steps[i_step_str].poly, param.verbose)
sct.printv(' dof ............ '+paramreg.steps[i_step_str].dof, param.verbose)
sct.printv(' smoothWarpXY ... '+paramreg.steps[i_step_str].smoothWarpXY, param.verbose)
# set metricSize
if paramreg.steps[i_step_str].metric == 'MI':
metricSize = '32' # corresponds to number of bins
else:
metricSize = '4' # corresponds to radius (for CC, MeanSquares...)
# set masking
if param.fname_mask:
fname_mask = 'mask.nii.gz'
masking = '-x mask.nii.gz'
else:
fname_mask = ''
masking = ''
if paramreg.steps[i_step_str].algo == 'slicereg':
# check if user used type=label
if paramreg.steps[i_step_str].type == 'label':
sct.printv('\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg', 1, 'error')
else:
from msct_image import find_zmin_zmax
# threshold images (otherwise, automatic crop does not work -- see issue #293)
src_th = sct.add_suffix(src, '_th')
from msct_image import Image
nii = Image(src)
data = nii.data
data[data < 0.1] = 0
nii.data = data
nii.setFileName(src_th)
nii.save()
# sct.run(fsloutput+'fslmaths '+src+' -thr 0.1 '+src_th, param.verbose)
dest_th = sct.add_suffix(dest, '_th')
nii = Image(dest)
data = nii.data
data[data < 0.1] = 0
nii.data = data
nii.setFileName(dest_th)
nii.save()
# sct.run(fsloutput+'fslmaths '+dest+' -thr 0.1 '+dest_th, param.verbose)
# find zmin and zmax
zmin_src, zmax_src = find_zmin_zmax(src_th)
zmin_dest, zmax_dest = find_zmin_zmax(dest_th)
zmin_total = max([zmin_src, zmin_dest])
zmax_total = min([zmax_src, zmax_dest])
# crop data
src_crop = sct.add_suffix(src, '_crop')
sct.run('sct_crop_image -i '+src+' -o '+src_crop+' -dim 2 -start '+str(zmin_total)+' -end '+str(zmax_total), param.verbose)
dest_crop = sct.add_suffix(dest, '_crop')
sct.run('sct_crop_image -i '+dest+' -o '+dest_crop+' -dim 2 -start '+str(zmin_total)+' -end '+str(zmax_total), param.verbose)
# update variables
src = src_crop
dest = dest_crop
scr_regStep = sct.add_suffix(src, '_regStep'+i_step_str)
# estimate transfo
cmd = ('isct_antsSliceRegularizedRegistration '
'-t Translation[0.5] '
'-m '+paramreg.steps[i_step_str].metric+'['+dest+','+src+',1,'+metricSize+',Regular,0.2] '
'-p '+paramreg.steps[i_step_str].poly+' '
'-i '+paramreg.steps[i_step_str].iter+' '
'-f 1 '
'-s '+paramreg.steps[i_step_str].smooth+' '
'-v 1 ' # verbose (verbose=2 does not exist, so we force it to 1)
'-o [step'+i_step_str+','+scr_regStep+'] ' # here the warp name is stage10 because antsSliceReg add "Warp"
+masking)
warp_forward_out = 'step'+i_step_str+'Warp.nii.gz'
warp_inverse_out = 'step'+i_step_str+'InverseWarp.nii.gz'
# run command
status, output = sct.run(cmd, param.verbose)
# ANTS 3d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params and paramreg.steps[i_step_str].slicewise == '0':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
# Pad the destination image (because ants doesn't deform the extremities)
# N.B. no need to pad if iter = 0
if not paramreg.steps[i_step_str].iter == '0':
dest_pad = sct.add_suffix(dest, '_pad')
sct.run('sct_image -i '+dest+' -o '+dest_pad+' -pad 0,0,'+str(param.padding))
dest = dest_pad
# apply Laplacian filter
if not paramreg.steps[i_step_str].laplacian == '0':
sct.printv('\nApply Laplacian filter', param.verbose)
sct.run('sct_maths -i '+src+' -laplacian '+paramreg.steps[i_step_str].laplacian+','+paramreg.steps[i_step_str].laplacian+',0 -o '+sct.add_suffix(src, '_laplacian'))
sct.run('sct_maths -i '+dest+' -laplacian '+paramreg.steps[i_step_str].laplacian+','+paramreg.steps[i_step_str].laplacian+',0 -o '+sct.add_suffix(dest, '_laplacian'))
src = sct.add_suffix(src, '_laplacian')
dest = sct.add_suffix(dest, '_laplacian')
# Estimate transformation
sct.printv('\nEstimate transformation', param.verbose)
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
cmd = ('isct_antsRegistration '
'--dimensionality 3 '
'--transform '+paramreg.steps[i_step_str].algo+'['+paramreg.steps[i_step_str].gradStep +
ants_registration_params[paramreg.steps[i_step_str].algo.lower()]+'] '
'--metric '+paramreg.steps[i_step_str].metric+'['+dest+','+src+',1,'+metricSize+'] '
'--convergence '+paramreg.steps[i_step_str].iter+' '
'--shrink-factors '+paramreg.steps[i_step_str].shrink+' '
'--smoothing-sigmas '+paramreg.steps[i_step_str].smooth+'mm '
'--restrict-deformation 1x1x0 '
'--output [step'+i_step_str+','+scr_regStep+'] '
'--interpolation BSpline[3] '
+masking)
# add verbose
if param.verbose >= 1:
cmd += ' --verbose 1'
# add init translation
if not paramreg.steps[i_step_str].init == '':
init_dict = {'geometric': '0', 'centermass': '1', 'origin': '2'}
cmd += ' -r ['+dest+','+src+','+init_dict[paramreg.steps[i_step_str].init]+']'
# run command
status, output = sct.run(cmd, param.verbose)
# get appropriate file name for transformation
if paramreg.steps[i_step_str].algo in ['rigid', 'affine', 'translation']:
warp_forward_out = 'step'+i_step_str+'0GenericAffine.mat'
warp_inverse_out = '-step'+i_step_str+'0GenericAffine.mat'
else:
warp_forward_out = 'step'+i_step_str+'0Warp.nii.gz'
warp_inverse_out = 'step'+i_step_str+'0InverseWarp.nii.gz'
# ANTS 2d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params and paramreg.steps[i_step_str].slicewise == '1':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
from msct_register import register_slicewise
# if shrink!=1, force it to be 1 (otherwise, it generates a wrong 3d warping field). TODO: fix that!
if not paramreg.steps[i_step_str].shrink == '1':
sct.printv('\nWARNING: when using slicewise with SyN or BSplineSyN, shrink factor needs to be one. Forcing shrink=1.', 1, 'warning')
paramreg.steps[i_step_str].shrink = '1'
warp_forward_out = 'step'+i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step'+i_step_str + 'InverseWarp.nii.gz'
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
path_qc=param.path_qc,
verbose=param.verbose)
# slice-wise transfo
elif paramreg.steps[i_step_str].algo in ['centermass', 'centermassrot', 'columnwise']:
# if type=im, sends warning
if paramreg.steps[i_step_str].type == 'im':
sct.printv('\nWARNING: algo '+paramreg.steps[i_step_str].algo+' should be used with type=seg.\n', 1, 'warning')
# if type=label, exit with error
elif paramreg.steps[i_step_str].type == 'label':
sct.printv('\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg', 1, 'error')
# check if user provided a mask-- if so, inform it will be ignored
if not fname_mask == '':
sct.printv('\nWARNING: algo '+paramreg.steps[i_step_str].algo+' will ignore the provided mask.\n', 1, 'warning')
# smooth data
if not paramreg.steps[i_step_str].smooth == '0':
sct.printv('\nSmooth data', param.verbose)
sct.run('sct_maths -i '+src+' -smooth '+paramreg.steps[i_step_str].smooth+','+paramreg.steps[i_step_str].smooth+',0 -o '+sct.add_suffix(src, '_smooth'))
sct.run('sct_maths -i '+dest+' -smooth '+paramreg.steps[i_step_str].smooth+','+paramreg.steps[i_step_str].smooth+',0 -o '+sct.add_suffix(dest, '_smooth'))
src = sct.add_suffix(src, '_smooth')
dest = sct.add_suffix(dest, '_smooth')
from msct_register import register_slicewise
warp_forward_out = 'step'+i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step'+i_step_str + 'InverseWarp.nii.gz'
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
path_qc=param.path_qc,
verbose=param.verbose)
else:
sct.printv('\nERROR: algo '+paramreg.steps[i_step_str].algo+' does not exist. Exit program\n', 1, 'error')
# landmark-based registration
if paramreg.steps[i_step_str].type in ['label']:
# check if user specified ilabel and dlabel
# TODO
warp_forward_out = 'step' + i_step_str + '0GenericAffine.txt'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.txt'
from msct_register_landmarks import register_landmarks
register_landmarks(src,
dest,
paramreg.steps[i_step_str].dof,
fname_affine=warp_forward_out,
verbose=param.verbose,
path_qc=param.path_qc)
if not os.path.isfile(warp_forward_out):
# no forward warping field for rigid and affine
sct.printv('\nERROR: file '+warp_forward_out+' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
elif not os.path.isfile(warp_inverse_out) and paramreg.steps[i_step_str].algo not in ['rigid', 'affine', 'translation'] and paramreg.steps[i_step_str].type not in ['label']:
# no inverse warping field for rigid and affine
sct.printv('\nERROR: file '+warp_inverse_out+' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
else:
# rename warping fields
if (paramreg.steps[i_step_str].algo.lower() in ['rigid', 'affine', 'translation'] and paramreg.steps[i_step_str].slicewise == '0'):
# if ANTs is used with affine/rigid --> outputs .mat file
warp_forward = 'warp_forward_'+i_step_str+'.mat'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_'+i_step_str+'.mat'
elif paramreg.steps[i_step_str].type in ['label']:
# if label-based registration is used --> outputs .txt file
warp_forward = 'warp_forward_'+i_step_str+'.txt'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_'+i_step_str+'.txt'
else:
warp_forward = 'warp_forward_'+i_step_str+'.nii.gz'
warp_inverse = 'warp_inverse_'+i_step_str+'.nii.gz'
os.rename(warp_forward_out, warp_forward)
os.rename(warp_inverse_out, warp_inverse)
return warp_forward, warp_inverse
def main(args=None):
# initializations
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_data = arguments['-i']
fname_seg = arguments['-s']
if '-l' in arguments:
fname_landmarks = arguments['-l']
label_type = 'body'
elif '-ldisc' in arguments:
fname_landmarks = arguments['-ldisc']
label_type = 'disc'
else:
sct.printv('ERROR: Labels should be provided.', 1, 'error')
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
param.path_qc = arguments.get("-qc", None)
path_template = arguments['-t']
contrast_template = arguments['-c']
ref = arguments['-ref']
param.remove_temp_files = int(arguments.get('-r'))
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
param_centerline = ParamCenterline(
algo_fitting=arguments['-centerline-algo'],
smooth=arguments['-centerline-smooth'])
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
zsubsample = param.zsubsample
# retrieve template file names
file_template_vertebral_labeling = get_file_label(os.path.join(path_template, 'template'), 'vertebral labeling')
file_template = get_file_label(os.path.join(path_template, 'template'), contrast_template.upper() + '-weighted template')
file_template_seg = get_file_label(os.path.join(path_template, 'template'), 'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = os.path.join(path_template, 'template', file_template)
fname_template_vertebral_labeling = os.path.join(path_template, 'template', file_template_vertebral_labeling)
fname_template_seg = os.path.join(path_template, 'template', file_template_seg)
fname_template_disc_labeling = os.path.join(path_template, 'template', 'PAM50_label_disc.nii.gz')
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
# sct.printv(arguments)
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: ' + fname_data, verbose)
sct.printv(' Landmarks: ' + fname_landmarks, verbose)
sct.printv(' Segmentation: ' + fname_seg, verbose)
sct.printv(' Path template: ' + path_template, verbose)
sct.printv(' Remove temp files: ' + str(param.remove_temp_files), verbose)
# check input labels
labels = check_labels(fname_landmarks, label_type=label_type)
vertebral_alignment = False
if len(labels) > 2 and label_type == 'disc':
vertebral_alignment = True
path_tmp = sct.tmp_create(basename="register_to_template", verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
Image(fname_data).save(os.path.join(path_tmp, ftmp_data))
Image(fname_seg).save(os.path.join(path_tmp, ftmp_seg))
Image(fname_landmarks).save(os.path.join(path_tmp, ftmp_label))
Image(fname_template).save(os.path.join(path_tmp, ftmp_template))
Image(fname_template_seg).save(os.path.join(path_tmp, ftmp_template_seg))
Image(fname_template_vertebral_labeling).save(os.path.join(path_tmp, ftmp_template_label))
if label_type == 'disc':
Image(fname_template_disc_labeling).save(os.path.join(path_tmp, ftmp_template_label))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Generate labels from template vertebral labeling
if label_type == 'body':
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
ftmp_template_label_, ftmp_template_label = ftmp_template_label, sct.add_suffix(ftmp_template_label, "_body")
sct_label_utils.main(args=['-i', ftmp_template_label_, '-vert-body', '0', '-o', ftmp_template_label])
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
# if only one label is present, force affine transformation to be Tx,Ty,Tz only (no scaling)
if len(labels) == 1:
paramreg.steps['0'].dof = 'Tx_Ty_Tz'
sct.printv('WARNING: Only one label is present. Forcing initial transformation to: ' + paramreg.steps['0'].dof,
1, 'warning')
# Project labels onto the spinal cord centerline because later, an affine transformation is estimated between the
# template's labels (centered in the cord) and the subject's labels (assumed to be centered in the cord).
# If labels are not centered, mis-registration errors are observed (see issue #1826)
ftmp_label = project_labels_on_spinalcord(ftmp_label, ftmp_seg, param_centerline)
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
ftmp_seg_, ftmp_seg = ftmp_seg, sct.add_suffix(ftmp_seg, "_bin")
sct_maths.main(['-i', ftmp_seg_,
'-bin', '0.5',
'-o', ftmp_seg])
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
resample_file(ftmp_data, add_suffix(ftmp_data, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_data = add_suffix(ftmp_data, '_1mm')
resample_file(ftmp_seg, add_suffix(ftmp_seg, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling
# with nearest neighbour can make them disappear.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
if vertebral_alignment:
# cropping the segmentation based on the label coverage to ensure good registration with vertebral alignment
# See https://github.com/neuropoly/spinalcordtoolbox/pull/1669 for details
image_labels = Image(ftmp_label)
coordinates_labels = image_labels.getNonZeroCoordinates(sorting='z')
nx, ny, nz, nt, px, py, pz, pt = image_labels.dim
offset_crop = 10.0 * pz # cropping the image 10 mm above and below the highest and lowest label
cropping_slices = [coordinates_labels[0].z - offset_crop, coordinates_labels[-1].z + offset_crop]
# make sure that the cropping slices do not extend outside of the slice range (issue #1811)
if cropping_slices[0] < 0:
cropping_slices[0] = 0
if cropping_slices[1] > nz:
cropping_slices[1] = nz
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, np.int32(np.round(cropping_slices))),))).save(ftmp_seg)
else:
# if we do not align the vertebral levels, we crop the segmentation from top to bottom
im_seg_rpi = Image(ftmp_seg_)
bottom = 0
for data in msct_image.SlicerOneAxis(im_seg_rpi, "IS"):
if (data != 0).any():
break
bottom += 1
top = im_seg_rpi.data.shape[2]
for data in msct_image.SlicerOneAxis(im_seg_rpi, "SI"):
if (data != 0).any():
break
top -= 1
msct_image.spatial_crop(im_seg_rpi, dict(((2, (bottom, top)),))).save(ftmp_seg)
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
fn_warp_curve2straight = os.path.join(curdir, "warp_curve2straight.nii.gz")
fn_warp_straight2curve = os.path.join(curdir, "warp_straight2curve.nii.gz")
fn_straight_ref = os.path.join(curdir, "straight_ref.nii.gz")
cache_input_files=[ftmp_seg]
if vertebral_alignment:
cache_input_files += [
ftmp_template_seg,
ftmp_label,
ftmp_template_label,
]
cache_sig = sct.cache_signature(
input_files=cache_input_files,
)
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(cachefile, cache_sig) and os.path.isfile(fn_warp_curve2straight) and os.path.isfile(fn_warp_straight2curve) and os.path.isfile(fn_straight_ref):
sct.printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
sct.copy(fn_warp_curve2straight, 'warp_curve2straight.nii.gz')
sct.copy(fn_warp_straight2curve, 'warp_straight2curve.nii.gz')
sct.copy(fn_straight_ref, 'straight_ref.nii.gz')
# apply straightening
sct_apply_transfo.main(args=[
'-i', ftmp_seg,
'-w', 'warp_curve2straight.nii.gz',
'-d', 'straight_ref.nii.gz',
'-o', add_suffix(ftmp_seg, '_straight')])
else:
from spinalcordtoolbox.straightening import SpinalCordStraightener
sc_straight = SpinalCordStraightener(ftmp_seg, ftmp_seg)
sc_straight.param_centerline = param_centerline
sc_straight.output_filename = add_suffix(ftmp_seg, '_straight')
sc_straight.path_output = './'
sc_straight.qc = '0'
sc_straight.remove_temp_files = param.remove_temp_files
sc_straight.verbose = verbose
if vertebral_alignment:
sc_straight.centerline_reference_filename = ftmp_template_seg
sc_straight.use_straight_reference = True
sc_straight.discs_input_filename = ftmp_label
sc_straight.discs_ref_filename = ftmp_template_label
sc_straight.straighten()
sct.cache_save(cachefile, cache_sig)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
sct_concat_transfo.main(args=[
'-w', 'warp_straight2curve.nii.gz',
'-d', ftmp_data,
'-o', 'warp_straight2curve.nii.gz'])
if vertebral_alignment:
sct.copy('warp_curve2straight.nii.gz', 'warp_curve2straightAffine.nii.gz')
else:
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct_maths.main(['-i', ftmp_label,
'-dilate', '3',
'-o', add_suffix(ftmp_label, '_dilate')])
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct_apply_transfo.main(args=[
'-i', ftmp_label,
'-o', add_suffix(ftmp_label, '_straight'),
'-d', add_suffix(ftmp_seg, '_straight'),
'-w', 'warp_curve2straight.nii.gz',
'-x', 'nn'])
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof,
fname_affine='straight2templateAffine.txt', verbose=verbose)
except RuntimeError:
raise('Input labels do not seem to be at the right place. Please check the position of the labels. '
'See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct_concat_transfo.main(args=[
'-w', ['warp_curve2straight.nii.gz', 'straight2templateAffine.txt'],
'-d', 'template.nii',
'-o', 'warp_curve2straightAffine.nii.gz'])
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct_apply_transfo.main(args=[
'-i', ftmp_data,
'-o', add_suffix(ftmp_data, '_straightAffine'),
'-d', ftmp_template,
'-w', 'warp_curve2straightAffine.nii.gz'])
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct_apply_transfo.main(args=[
'-i', ftmp_seg,
'-o', add_suffix(ftmp_seg, '_straightAffine'),
'-d', ftmp_template,
'-w', 'warp_curve2straightAffine.nii.gz',
'-x', 'linear'])
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(np.round(np.min(points_straight))), int(np.round(np.max(points_straight)))
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_black')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (min_point,max_point)),))).save(ftmp_seg)
"""
# open segmentation
im = Image(ftmp_seg)
im_new = msct_image.empty_like(im)
# binarize
im_new.data = im.data > 0.5
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = msct_image.find_zmin_zmax(im_new, threshold=0.5)
# save binarized segmentation
im_new.save(add_suffix(ftmp_seg, '_bin')) # unused?
# crop template in z-direction (for faster processing)
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
ftmp_template_, ftmp_template = ftmp_template, add_suffix(ftmp_template, '_crop')
msct_image.spatial_crop(Image(ftmp_template_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template)
ftmp_template_seg_, ftmp_template_seg = ftmp_template_seg, add_suffix(ftmp_template_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_template_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template_seg)
ftmp_data_, ftmp_data = ftmp_data, add_suffix(ftmp_data, '_crop')
msct_image.spatial_crop(Image(ftmp_data_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_data)
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_seg)
# sub-sample in z-direction
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run(['sct_resample', '-i', ftmp_template, '-o', add_suffix(ftmp_template, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run(['sct_resample', '-i', ftmp_template_seg, '-o', add_suffix(ftmp_template_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run(['sct_resample', '-i', ftmp_data, '-o', add_suffix(ftmp_data, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run(['sct_resample', '-i', ftmp_seg, '-o', add_suffix(ftmp_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog':
src_seg = ftmp_seg
dest_seg = ftmp_template_seg
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# apply transformation from previous step, to use as new src for registration
sct_apply_transfo.main(args=[
'-i', src,
'-d', dest,
'-w', warp_forward,
'-o', add_suffix(src, '_regStep' + str(i_step - 1)),
'-x', interp_step])
src = add_suffix(src, '_regStep' + str(i_step - 1))
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # also apply transformation to the seg
sct_apply_transfo.main(args=[
'-i', src_seg,
'-d', dest_seg,
'-w', warp_forward,
'-o', add_suffix(src, '_regStep' + str(i_step - 1)),
'-x', interp_step])
src_seg = add_suffix(src_seg, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # im_seg case
warp_forward_out, warp_inverse_out = register([src, src_seg], [dest, dest_seg], paramreg, param, str(i_step))
else:
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations: anat --> template
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
warp_forward.insert(0, 'warp_curve2straightAffine.nii.gz')
sct_concat_transfo.main(args=[
'-w', warp_forward,
'-d', 'template.nii',
'-o', 'warp_anat2template.nii.gz'])
# Concatenate transformations: template --> anat
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
if vertebral_alignment:
warp_inverse.append('warp_straight2curve.nii.gz')
sct_concat_transfo.main(args=[
'-w', warp_inverse,
'-d', 'data.nii',
'-o', 'warp_template2anat.nii.gz'])
else:
warp_inverse.append('straight2templateAffine.txt')
warp_inverse.append('warp_straight2curve.nii.gz')
sct_concat_transfo.main(args=[
'-w', warp_inverse,
'-winv', ['straight2templateAffine.txt'],
'-d', 'data.nii',
'-o', 'warp_template2anat.nii.gz'])
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This
# new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = np.round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x), int(new_label.y), int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.absolutepath = 'label_rpi_modif.nii.gz'
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc="./")
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct_apply_transfo.main(args=[
'-i', src,
'-d', dest,
'-w', warp_forward,
'-o', add_suffix(src, '_regStep' + str(i_step - 1)),
'-x', interp_step])
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct_concat_transfo.main(args=[
'-w', warp_forward,
'-d', 'data.nii',
'-o', 'warp_template2anat.nii.gz'])
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct_concat_transfo.main(args=[
'-w', warp_inverse,
'-winv', ['template2subjectAffine.txt'],
'-d', 'template.nii',
'-o', 'warp_anat2template.nii.gz'])
# Apply warping fields to anat and template
sct.run(['sct_apply_transfo', '-i', 'template.nii', '-o', 'template2anat.nii.gz', '-d', 'data.nii', '-w', 'warp_template2anat.nii.gz', '-crop', '1'], verbose)
sct.run(['sct_apply_transfo', '-i', 'data.nii', '-o', 'anat2template.nii.gz', '-d', 'template.nii', '-w', 'warp_anat2template.nii.gz', '-crop', '1'], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
fname_template2anat = os.path.join(path_output, 'template2anat' + ext_data)
fname_anat2template = os.path.join(path_output, 'anat2template' + ext_data)
sct.generate_output_file(os.path.join(path_tmp, "warp_template2anat.nii.gz"), os.path.join(path_output, "warp_template2anat.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_anat2template.nii.gz"), os.path.join(path_output, "warp_anat2template.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "template2anat.nii.gz"), fname_template2anat, verbose)
sct.generate_output_file(os.path.join(path_tmp, "anat2template.nii.gz"), fname_anat2template, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"), os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"), os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"), os.path.join(path_output, "straight_ref.nii.gz"), verbose)
# Delete temporary files
if param.remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', verbose)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
if param.path_qc is not None:
generate_qc(fname_data, fname_in2=fname_template2anat, fname_seg=fname_seg, args=args,
path_qc=os.path.abspath(param.path_qc), dataset=qc_dataset, subject=qc_subject,
process='sct_register_to_template')
sct.display_viewer_syntax([fname_data, fname_template2anat], verbose=verbose)
sct.display_viewer_syntax([fname_template, fname_anat2template], verbose=verbose)
def main(args=None):
# initializations
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_data = arguments['-i']
fname_seg = arguments['-s']
if '-l' in arguments:
fname_landmarks = arguments['-l']
label_type = 'body'
elif '-ldisc' in arguments:
fname_landmarks = arguments['-ldisc']
label_type = 'disc'
else:
sct.printv('ERROR: Labels should be provided.', 1, 'error')
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
param.path_qc = arguments.get("-qc", None)
path_template = arguments['-t']
contrast_template = arguments['-c']
ref = arguments['-ref']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments['-v'])
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
if '-param-straighten' in arguments:
param.param_straighten = arguments['-param-straighten']
# if '-cpu-nb' in arguments:
# arg_cpu = ' -cpu-nb '+str(arguments['-cpu-nb'])
# else:
# arg_cpu = ''
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
# file_template_label = param.file_template_label
zsubsample = param.zsubsample
# smoothing_sigma = param.smoothing_sigma
# retrieve template file names
file_template_vertebral_labeling = get_file_label(
os.path.join(path_template, 'template'), 'vertebral labeling')
file_template = get_file_label(
os.path.join(path_template, 'template'),
contrast_template.upper() + '-weighted template')
file_template_seg = get_file_label(os.path.join(path_template, 'template'),
'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = os.path.join(path_template, 'template', file_template)
fname_template_vertebral_labeling = os.path.join(
path_template, 'template', file_template_vertebral_labeling)
fname_template_seg = os.path.join(path_template, 'template',
file_template_seg)
fname_template_disc_labeling = os.path.join(path_template, 'template',
'PAM50_label_disc.nii.gz')
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
# sct.printv(arguments)
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: ' + fname_data, verbose)
sct.printv(' Landmarks: ' + fname_landmarks, verbose)
sct.printv(' Segmentation: ' + fname_seg, verbose)
sct.printv(' Path template: ' + path_template, verbose)
sct.printv(' Remove temp files: ' + str(remove_temp_files), verbose)
# check if data, segmentation and landmarks are in the same space
# JULIEN 2017-04-25: removed because of issue #1168
# sct.printv('\nCheck if data, segmentation and landmarks are in the same space...')
# if not sct.check_if_same_space(fname_data, fname_seg):
# sct.printv('ERROR: Data image and segmentation are not in the same space. Please check space and orientation of your files', verbose, 'error')
# if not sct.check_if_same_space(fname_data, fname_landmarks):
# sct.printv('ERROR: Data image and landmarks are not in the same space. Please check space and orientation of your files', verbose, 'error')
# check input labels
labels = check_labels(fname_landmarks, label_type=label_type)
vertebral_alignment = False
if len(labels) > 2 and label_type == 'disc':
vertebral_alignment = True
path_tmp = sct.tmp_create(basename="register_to_template", verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# ftmp_template_label_disc = 'template_label_disc.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...',
verbose)
sct.run([
'sct_convert', '-i', fname_data, '-o',
os.path.join(path_tmp, ftmp_data)
])
sct.run([
'sct_convert', '-i', fname_seg, '-o',
os.path.join(path_tmp, ftmp_seg)
])
sct.run([
'sct_convert', '-i', fname_landmarks, '-o',
os.path.join(path_tmp, ftmp_label)
])
sct.run([
'sct_convert', '-i', fname_template, '-o',
os.path.join(path_tmp, ftmp_template)
])
sct.run([
'sct_convert', '-i', fname_template_seg, '-o',
os.path.join(path_tmp, ftmp_template_seg)
])
sct_convert.main(args=[
'-i', fname_template_vertebral_labeling, '-o',
os.path.join(path_tmp, ftmp_template_label)
])
if label_type == 'disc':
sct_convert.main(args=[
'-i', fname_template_disc_labeling, '-o',
os.path.join(path_tmp, ftmp_template_label)
])
# sct.run('sct_convert -i '+fname_template_label+' -o '+os.path.join(path_tmp, ftmp_template_label))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Generate labels from template vertebral labeling
if label_type == 'body':
sct.printv('\nGenerate labels from template vertebral labeling',
verbose)
sct_label_utils.main(args=[
'-i', ftmp_template_label, '-vert-body', '0', '-o',
ftmp_template_label
])
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template',
verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(
sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv(
'ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) +
'\nLabel max from template: ' + str(labels_template[-1].value),
verbose, 'error')
# if only one label is present, force affine transformation to be Tx,Ty,Tz only (no scaling)
if len(labels) == 1:
paramreg.steps['0'].dof = 'Tx_Ty_Tz'
sct.printv(
'WARNING: Only one label is present. Forcing initial transformation to: '
+ paramreg.steps['0'].dof, 1, 'warning')
# Project labels onto the spinal cord centerline because later, an affine transformation is estimated between the
# template's labels (centered in the cord) and the subject's labels (assumed to be centered in the cord).
# If labels are not centered, mis-registration errors are observed (see issue #1826)
ftmp_label = project_labels_on_spinalcord(ftmp_label, ftmp_seg)
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
sct.run(
['sct_maths', '-i', 'seg.nii.gz', '-bin', '0.5', '-o', 'seg.nii.gz'])
# smooth segmentation (jcohenadad, issue #613)
# sct.printv('\nSmooth segmentation...', verbose)
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 1.5 -o '+add_suffix(ftmp_seg, '_smooth'))
# jcohenadad: updated 2016-06-16: DO NOT smooth the seg anymore. Issue #
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 0 -o '+add_suffix(ftmp_seg, '_smooth'))
# ftmp_seg = add_suffix(ftmp_seg, '_smooth')
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
sct.run([
'sct_resample', '-i', ftmp_data, '-mm', '1.0x1.0x1.0', '-x',
'linear', '-o',
add_suffix(ftmp_data, '_1mm')
])
ftmp_data = add_suffix(ftmp_data, '_1mm')
sct.run([
'sct_resample', '-i', ftmp_seg, '-mm', '1.0x1.0x1.0', '-x',
'linear', '-o',
add_suffix(ftmp_seg, '_1mm')
])
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling
# with nearest neighbour can make them disappear.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run([
'sct_image', '-i', ftmp_data, '-setorient', 'RPI', '-o',
add_suffix(ftmp_data, '_rpi')
])
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run([
'sct_image', '-i', ftmp_seg, '-setorient', 'RPI', '-o',
add_suffix(ftmp_seg, '_rpi')
])
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run([
'sct_image', '-i', ftmp_label, '-setorient', 'RPI', '-o',
add_suffix(ftmp_label, '_rpi')
])
ftmp_label = add_suffix(ftmp_label, '_rpi')
if vertebral_alignment:
# cropping the segmentation based on the label coverage to ensure good registration with vertebral alignment
# See https://github.com/neuropoly/spinalcordtoolbox/pull/1669 for details
image_labels = Image(ftmp_label)
coordinates_labels = image_labels.getNonZeroCoordinates(
sorting='z')
nx, ny, nz, nt, px, py, pz, pt = image_labels.dim
offset_crop = 10.0 * pz # cropping the image 10 mm above and below the highest and lowest label
cropping_slices = [
coordinates_labels[0].z - offset_crop,
coordinates_labels[-1].z + offset_crop
]
# make sure that the cropping slices do not extend outside of the slice range (issue #1811)
if cropping_slices[0] < 0:
cropping_slices[0] = 0
if cropping_slices[1] > nz:
cropping_slices[1] = nz
status_crop, output_crop = sct.run([
'sct_crop_image', '-i', ftmp_seg, '-o',
add_suffix(ftmp_seg, '_crop'), '-dim', '2', '-start',
str(cropping_slices[0]), '-end',
str(cropping_slices[1])
], verbose)
else:
# if we do not align the vertebral levels, we crop the segmentation from top to bottom
status_crop, output_crop = sct.run([
'sct_crop_image', '-i', ftmp_seg, '-o',
add_suffix(ftmp_seg, '_crop'), '-dim', '2', '-bzmax'
], verbose)
cropping_slices = output_crop.split('Dimension 2: ')[1].split(
'\n')[0].split(' ')
# output: segmentation_rpi_crop.nii.gz
ftmp_seg = add_suffix(ftmp_seg, '_crop')
# straighten segmentation
sct.printv(
'\nStraighten the spinal cord using centerline/segmentation...',
verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
fn_warp_curve2straight = os.path.join(curdir,
"warp_curve2straight.nii.gz")
fn_warp_straight2curve = os.path.join(curdir,
"warp_straight2curve.nii.gz")
fn_straight_ref = os.path.join(curdir, "straight_ref.nii.gz")
cache_input_files = [ftmp_seg]
if vertebral_alignment:
cache_input_files += [
ftmp_template_seg,
ftmp_label,
ftmp_template_label,
]
cache_sig = sct.cache_signature(input_files=cache_input_files, )
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(
cachefile, cache_sig
) and os.path.isfile(fn_warp_curve2straight) and os.path.isfile(
fn_warp_straight2curve) and os.path.isfile(fn_straight_ref):
sct.printv(
'Reusing existing warping field which seems to be valid',
verbose, 'warning')
sct.copy(fn_warp_curve2straight, 'warp_curve2straight.nii.gz')
sct.copy(fn_warp_straight2curve, 'warp_straight2curve.nii.gz')
sct.copy(fn_straight_ref, 'straight_ref.nii.gz')
# apply straightening
sct.run([
'sct_apply_transfo', '-i', ftmp_seg, '-w',
'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz',
'-o',
add_suffix(ftmp_seg, '_straight')
])
else:
from sct_straighten_spinalcord import SpinalCordStraightener
sc_straight = SpinalCordStraightener(ftmp_seg, ftmp_seg)
sc_straight.output_filename = add_suffix(ftmp_seg, '_straight')
sc_straight.path_output = './'
sc_straight.qc = '0'
sc_straight.remove_temp_files = remove_temp_files
sc_straight.verbose = verbose
if vertebral_alignment:
sc_straight.centerline_reference_filename = ftmp_template_seg
sc_straight.use_straight_reference = True
sc_straight.discs_input_filename = ftmp_label
sc_straight.discs_ref_filename = ftmp_template_label
sc_straight.straighten()
sct.cache_save(cachefile, cache_sig)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
sct.run([
'sct_concat_transfo', '-w', 'warp_straight2curve.nii.gz', '-d',
ftmp_data, '-o', 'warp_straight2curve.nii.gz'
])
if vertebral_alignment:
sct.copy('warp_curve2straight.nii.gz',
'warp_curve2straightAffine.nii.gz')
else:
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv(
'\nRemove unused label on template. Keep only label present in the input label image...',
verbose)
sct.run([
'sct_label_utils', '-i', ftmp_template_label, '-o',
ftmp_template_label, '-remove', ftmp_label
])
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct.run([
'sct_maths', '-i', ftmp_label, '-o',
add_suffix(ftmp_label, '_dilate'), '-dilate', '3'
])
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run([
'sct_apply_transfo', '-i', ftmp_label, '-o',
add_suffix(ftmp_label, '_straight'), '-d',
add_suffix(ftmp_seg, '_straight'), '-w',
'warp_curve2straight.nii.gz', '-x', 'nn'
])
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
try:
register_landmarks(ftmp_label,
ftmp_template_label,
paramreg.steps['0'].dof,
fname_affine='straight2templateAffine.txt',
verbose=verbose)
except Exception:
sct.printv(
'ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/',
verbose=verbose,
type='error')
# Concatenate transformations: curve --> straight --> affine
sct.printv(
'\nConcatenate transformations: curve --> straight --> affine...',
verbose)
sct.run([
'sct_concat_transfo', '-w',
'warp_curve2straight.nii.gz,straight2templateAffine.txt', '-d',
'template.nii', '-o', 'warp_curve2straightAffine.nii.gz'
])
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run([
'sct_apply_transfo', '-i', ftmp_data, '-o',
add_suffix(ftmp_data, '_straightAffine'), '-d', ftmp_template,
'-w', 'warp_curve2straightAffine.nii.gz'
])
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run([
'sct_apply_transfo', '-i', ftmp_seg, '-o',
add_suffix(ftmp_seg, '_straightAffine'), '-d', ftmp_template, '-w',
'warp_curve2straightAffine.nii.gz', '-x', 'linear'
])
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(round(np.min(points_straight))), int(round(np.max(points_straight)))
sct.run('sct_crop_image -i ' + ftmp_seg + ' -start ' + str(min_point) + ' -end ' + str(max_point) + ' -dim 2 -b 0 -o ' + add_suffix(ftmp_seg, '_black'))
ftmp_seg = add_suffix(ftmp_seg, '_black')
"""
# binarize
sct.printv('\nBinarize segmentation...', verbose)
sct.run([
'sct_maths', '-i', ftmp_seg, '-bin', '0.5', '-o',
add_suffix(ftmp_seg, '_bin')
])
ftmp_seg = add_suffix(ftmp_seg, '_bin')
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = find_zmin_zmax(ftmp_seg)
# crop template in z-direction (for faster processing)
sct.printv('\nCrop data in template space (for faster processing)...',
verbose)
sct.run([
'sct_crop_image', '-i', ftmp_template, '-o',
add_suffix(ftmp_template, '_crop'), '-dim', '2', '-start',
str(zmin_template), '-end',
str(zmax_template)
])
ftmp_template = add_suffix(ftmp_template, '_crop')
sct.run([
'sct_crop_image', '-i', ftmp_template_seg, '-o',
add_suffix(ftmp_template_seg, '_crop'), '-dim', '2', '-start',
str(zmin_template), '-end',
str(zmax_template)
])
ftmp_template_seg = add_suffix(ftmp_template_seg, '_crop')
sct.run([
'sct_crop_image', '-i', ftmp_data, '-o',
add_suffix(ftmp_data, '_crop'), '-dim', '2', '-start',
str(zmin_template), '-end',
str(zmax_template)
])
ftmp_data = add_suffix(ftmp_data, '_crop')
sct.run([
'sct_crop_image', '-i', ftmp_seg, '-o',
add_suffix(ftmp_seg, '_crop'), '-dim', '2', '-start',
str(zmin_template), '-end',
str(zmax_template)
])
ftmp_seg = add_suffix(ftmp_seg, '_crop')
# sub-sample in z-direction
sct.printv('\nSub-sample in z-direction (for faster processing)...',
verbose)
sct.run([
'sct_resample', '-i', ftmp_template, '-o',
add_suffix(ftmp_template, '_sub'), '-f', '1x1x' + zsubsample
], verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run([
'sct_resample', '-i', ftmp_template_seg, '-o',
add_suffix(ftmp_template_seg, '_sub'), '-f', '1x1x' + zsubsample
], verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run([
'sct_resample', '-i', ftmp_data, '-o',
add_suffix(ftmp_data, '_sub'), '-f', '1x1x' + zsubsample
], verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run([
'sct_resample', '-i', ftmp_seg, '-o',
add_suffix(ftmp_seg, '_sub'), '-f', '1x1x' + zsubsample
], verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv(
'\nEstimate transformation for step #' + str(i_step) + '...',
verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+sct.add_suffix(src, '_reg')+' -x '+interp_step, verbose)
# apply transformation from previous step, to use as new src for registration
sct.run([
'sct_apply_transfo', '-i', src, '-d', dest, '-w',
','.join(warp_forward), '-o',
add_suffix(src,
'_regStep' + str(i_step - 1)), '-x', interp_step
], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(
src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...',
verbose)
sct.run([
'sct_concat_transfo', '-w',
'warp_curve2straightAffine.nii.gz,' + ','.join(warp_forward), '-d',
'template.nii', '-o', 'warp_anat2template.nii.gz'
], verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...',
verbose)
warp_inverse.reverse()
if vertebral_alignment:
sct.run([
'sct_concat_transfo', '-w',
','.join(warp_inverse) + ',warp_straight2curve.nii.gz', '-d',
'data.nii', '-o', 'warp_template2anat.nii.gz'
], verbose)
else:
sct.run([
'sct_concat_transfo', '-w', ','.join(warp_inverse) +
',-straight2templateAffine.txt,warp_straight2curve.nii.gz',
'-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'
], verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run([
'sct_image', '-i', ftmp_data, '-setorient', 'RPI', '-o',
add_suffix(ftmp_data, '_rpi')
])
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run([
'sct_image', '-i', ftmp_seg, '-setorient', 'RPI', '-o',
add_suffix(ftmp_seg, '_rpi')
])
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run([
'sct_image', '-i', ftmp_label, '-setorient', 'RPI', '-o',
add_suffix(ftmp_label, '_rpi')
])
ftmp_label = add_suffix(ftmp_label, '_rpi')
# Remove unused label on template. Keep only label present in the input label image
sct.printv(
'\nRemove unused label on template. Keep only label present in the input label image...',
verbose)
sct.run([
'sct_label_utils', '-i', ftmp_template_label, '-o',
ftmp_template_label, '-remove', ftmp_label
])
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This
# new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue(
) # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x),
int(new_label.y),
int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.setFileName('label_rpi_modif.nii.gz')
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label,
ftmp_label,
paramreg.steps['0'].dof,
fname_affine=warp_forward[0],
verbose=verbose,
path_qc="./")
except Exception:
sct.printv(
'ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/',
verbose=verbose,
type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv(
'\nEstimate transformation for step #' + str(i_step) + '...',
verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run([
'sct_apply_transfo', '-i', src, '-d', dest, '-w',
','.join(warp_forward), '-o',
add_suffix(src,
'_regStep' + str(i_step - 1)), '-x', interp_step
], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(
src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...',
verbose)
sct.run([
'sct_concat_transfo', '-w', ','.join(warp_forward), '-d',
'data.nii', '-o', 'warp_template2anat.nii.gz'
], verbose)
sct.printv('\nConcatenate transformations: subject --> template...',
verbose)
sct.run([
'sct_concat_transfo', '-w', ','.join(warp_inverse), '-d',
'template.nii', '-o', 'warp_anat2template.nii.gz'
], verbose)
# Apply warping fields to anat and template
sct.run([
'sct_apply_transfo', '-i', 'template.nii', '-o',
'template2anat.nii.gz', '-d', 'data.nii', '-w',
'warp_template2anat.nii.gz', '-crop', '1'
], verbose)
sct.run([
'sct_apply_transfo', '-i', 'data.nii', '-o', 'anat2template.nii.gz',
'-d', 'template.nii', '-w', 'warp_anat2template.nii.gz', '-crop', '1'
], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
fname_template2anat = os.path.join(path_output, 'template2anat' + ext_data)
fname_anat2template = os.path.join(path_output, 'anat2template' + ext_data)
sct.generate_output_file(
os.path.join(path_tmp, "warp_template2anat.nii.gz"),
os.path.join(path_output, "warp_template2anat.nii.gz"), verbose)
sct.generate_output_file(
os.path.join(path_tmp, "warp_anat2template.nii.gz"),
os.path.join(path_output, "warp_anat2template.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "template2anat.nii.gz"),
fname_template2anat, verbose)
sct.generate_output_file(os.path.join(path_tmp, "anat2template.nii.gz"),
fname_anat2template, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(
os.path.join(path_tmp, "warp_curve2straight.nii.gz"),
os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose)
sct.generate_output_file(
os.path.join(path_tmp, "warp_straight2curve.nii.gz"),
os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose)
sct.generate_output_file(
os.path.join(path_tmp, "straight_ref.nii.gz"),
os.path.join(path_output, "straight_ref.nii.gz"), verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv(
'\nFinished! Elapsed time: ' + str(int(round(elapsed_time))) + 's',
verbose)
if param.path_qc is not None:
generate_qc(fname_data, fname_template2anat, fname_seg, args,
os.path.abspath(param.path_qc))
sct.display_viewer_syntax([fname_data, fname_template2anat],
verbose=verbose)
sct.display_viewer_syntax([fname_template, fname_anat2template],
verbose=verbose)
def main():
parser = get_parser()
param = Param()
""" Rewrite arguments and set parameters"""
arguments = parser.parse(sys.argv[1:])
(fname_data, fname_landmarks, path_output, path_template, contrast_template, ref, remove_temp_files,
verbose, init_labels, first_label,nb_slice_to_mean)=rewrite_arguments(arguments)
(param, paramreg)=write_paramaters(arguments,param,ref,verbose)
if(init_labels):
use_viewer_to_define_labels(fname_data,first_label,nb_slice_to_mean)
# initialize other parameters
# file_template_label = param.file_template_label
zsubsample = param.zsubsample
template = os.path.basename(os.path.normpath(pth_template))
# smoothing_sigma = param.smoothing_sigma
# retrieve template file names
from sct_warp_template import get_file_label
file_template_vertebral_labeling = get_file_label(path_template+'template/', 'vertebral')
file_template = get_file_label(path_template+'template/', contrast_template.upper()+'-weighted')
file_template_seg = get_file_label(path_template+'template/', 'spinal cord')
""" Start timer"""
start_time = time.time()
""" Manage file of templates"""
(fname_template, fname_template_vertebral_labeling, fname_template_seg)=make_fname_of_templates(file_template,path_template,file_template_vertebral_labeling,file_template_seg)
check_do_files_exist(fname_template,fname_template_vertebral_labeling,fname_template_seg,verbose)
sct.printv(arguments(verbose, fname_data, fname_landmarks, fname_seg, path_template, remove_temp_files))
""" Create QC folder """
sct.create_folder(param.path_qc)
""" Check if data, segmentation and landmarks are in the same space"""
(ext_data, path_data, file_data)=check_data_segmentation_landmarks_same_space(fname_data, fname_seg, fname_landmarks,verbose)
''' Check input labels'''
labels = check_labels(fname_landmarks)
""" Create temporary folder, set temporary file names, copy files into it and go in it """
path_tmp = sct.tmp_create(verbose=verbose)
(ftmp_data, ftmp_seg, ftmp_label, ftmp_template, ftmp_template_seg, ftmp_template_label)=set_temporary_files()
copy_files_to_temporary_files(verbose, fname_data, path_tmp, ftmp_seg, ftmp_data, fname_seg, fname_landmarks,
ftmp_label, fname_template, ftmp_template, fname_template_seg, ftmp_template_seg)
os.chdir(path_tmp)
''' Generate labels from template vertebral labeling'''
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
sct.run('sct_label_utils -i '+fname_template_vertebral_labeling+' -vert-body 0 -o '+ftmp_template_label)
''' Check if provided labels are available in the template'''
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
''' Binarize segmentation (in case it has values below 0 caused by manual editing)'''
sct.printv('\nBinarize segmentation', verbose)
sct.run('sct_maths -i seg.nii.gz -bin 0.5 -o seg.nii.gz')
# smooth segmentation (jcohenadad, issue #613)
# sct.printv('\nSmooth segmentation...', verbose)
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 1.5 -o '+add_suffix(ftmp_seg, '_smooth'))
# jcohenadad: updated 2016-06-16: DO NOT smooth the seg anymore. Issue #
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 0 -o '+add_suffix(ftmp_seg, '_smooth'))
# ftmp_seg = add_suffix(ftmp_seg, '_smooth')
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
sct.run('sct_resample -i '+ftmp_data+' -mm 1.0x1.0x1.0 -x linear -o '+add_suffix(ftmp_data, '_1mm'))
ftmp_data = add_suffix(ftmp_data, '_1mm')
sct.run('sct_resample -i '+ftmp_seg+' -mm 1.0x1.0x1.0 -x linear -o '+add_suffix(ftmp_seg, '_1mm'))
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling with neighrest neighbour can make them disappear. Therefore a more clever approach is required.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i '+ftmp_data+' -setorient RPI -o '+add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i '+ftmp_seg+' -setorient RPI -o '+add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i '+ftmp_label+' -setorient RPI -o '+add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# get landmarks in native space
# crop segmentation
# output: segmentation_rpi_crop.nii.gz
status_crop, output_crop = sct.run('sct_crop_image -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_crop')+' -dim 2 -bzmax', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_crop')
cropping_slices = output_crop.split('Dimension 2: ')[1].split('\n')[0].split(' ')
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
if os.path.isfile('../warp_curve2straight.nii.gz') and os.path.isfile('../warp_straight2curve.nii.gz') and os.path.isfile('../straight_ref.nii.gz'):
# if they exist, copy them into current folder
sct.printv('WARNING: Straightening was already run previously. Copying warping fields...', verbose, 'warning')
shutil.copy('../warp_curve2straight.nii.gz', 'warp_curve2straight.nii.gz')
shutil.copy('../warp_straight2curve.nii.gz', 'warp_straight2curve.nii.gz')
shutil.copy('../straight_ref.nii.gz', 'straight_ref.nii.gz')
# apply straightening
sct.run('sct_apply_transfo -i '+ftmp_seg+' -w warp_curve2straight.nii.gz -d straight_ref.nii.gz -o '+add_suffix(ftmp_seg, '_straight'))
else:
sct.run('sct_straighten_spinalcord -i '+ftmp_seg+' -s '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_straight')+' -qc 0 -r 0 -v '+str(verbose), verbose)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
sct.run('sct_concat_transfo -w warp_straight2curve.nii.gz -d '+ftmp_data+' -o warp_straight2curve.nii.gz')
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i '+ftmp_template_label+' -o '+ftmp_template_label+' -remove '+ftmp_label)
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct.run('sct_maths -i '+ftmp_label+' -o '+add_suffix(ftmp_label, '_dilate')+' -dilate 3')
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run('sct_apply_transfo -i '+ftmp_label+' -o '+add_suffix(ftmp_label, '_straight')+' -d '+add_suffix(ftmp_seg, '_straight')+' -w warp_curve2straight.nii.gz -x nn')
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof, fname_affine='straight2templateAffine.txt', verbose=verbose)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt -d template.nii -o warp_curve2straightAffine.nii.gz')
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run('sct_apply_transfo -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_straightAffine')+' -d '+ftmp_template+' -w warp_curve2straightAffine.nii.gz')
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run('sct_apply_transfo -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_straightAffine')+' -d '+ftmp_template+' -w warp_curve2straightAffine.nii.gz -x linear')
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(round(np.min(points_straight))), int(round(np.max(points_straight)))
sct.run('sct_crop_image -i ' + ftmp_seg + ' -start ' + str(min_point) + ' -end ' + str(max_point) + ' -dim 2 -b 0 -o ' + add_suffix(ftmp_seg, '_black'))
ftmp_seg = add_suffix(ftmp_seg, '_black')
"""
# binarize
sct.printv('\nBinarize segmentation...', verbose)
sct.run('sct_maths -i '+ftmp_seg+' -bin 0.5 -o '+add_suffix(ftmp_seg, '_bin'))
ftmp_seg = add_suffix(ftmp_seg, '_bin')
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = find_zmin_zmax(ftmp_seg)
# crop template in z-direction (for faster processing)
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
sct.run('sct_crop_image -i '+ftmp_template+' -o '+add_suffix(ftmp_template, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_template = add_suffix(ftmp_template, '_crop')
sct.run('sct_crop_image -i '+ftmp_template_seg+' -o '+add_suffix(ftmp_template_seg, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_template_seg = add_suffix(ftmp_template_seg, '_crop')
sct.run('sct_crop_image -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_data = add_suffix(ftmp_data, '_crop')
sct.run('sct_crop_image -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_seg = add_suffix(ftmp_seg, '_crop')
# sub-sample in z-direction
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run('sct_resample -i '+ftmp_template+' -o '+add_suffix(ftmp_template, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run('sct_resample -i '+ftmp_template_seg+' -o '+add_suffix(ftmp_template_seg, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run('sct_resample -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run('sct_resample -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #'+str(i_step)+'...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+sct.add_suffix(src, '_reg')+' -x '+interp_step, verbose)
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+add_suffix(src, '_regStep'+str(i_step-1))+' -x '+interp_step, verbose)
src = add_suffix(src, '_regStep'+str(i_step-1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straightAffine.nii.gz,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
sct.run('sct_concat_transfo -w '+','.join(warp_inverse)+',-straight2templateAffine.txt,warp_straight2curve.nii.gz -d data.nii -o warp_template2anat.nii.gz', verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i ' + ftmp_data + ' -setorient RPI -o ' + add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i ' + ftmp_seg + ' -setorient RPI -o ' + add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i ' + ftmp_label + ' -setorient RPI -o ' + add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i '+ftmp_template_label+' -o '+ftmp_template_label+' -remove '+ftmp_label)
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x), int(new_label.y), int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.setFileName('label_rpi_modif.nii.gz')
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc=param.path_qc)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #'+str(i_step)+'...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+add_suffix(src, '_regStep'+str(i_step-1))+' -x '+interp_step, verbose)
src = add_suffix(src, '_regStep'+str(i_step-1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct.run('sct_concat_transfo -w '+','.join(warp_forward)+' -d data.nii -o warp_template2anat.nii.gz', verbose)
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct.run('sct_concat_transfo -w '+','.join(warp_inverse)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
# Apply warping fields to anat and template
sct.run('sct_apply_transfo -i template.nii -o template2anat.nii.gz -d data.nii -w warp_template2anat.nii.gz -crop 1', verbose)
sct.run('sct_apply_transfo -i data.nii -o anat2template.nii.gz -d template.nii -w warp_anat2template.nii.gz -crop 1', verbose)
# come back to parent folder
os.chdir('..')
# Generate output files
sct.printv('\nGenerate output files...', verbose)
sct.generate_output_file(path_tmp+'warp_template2anat.nii.gz', path_output+'warp_template2anat.nii.gz', verbose)
sct.generate_output_file(path_tmp+'warp_anat2template.nii.gz', path_output+'warp_anat2template.nii.gz', verbose)
sct.generate_output_file(path_tmp+'template2anat.nii.gz', path_output+'template2anat'+ext_data, verbose)
sct.generate_output_file(path_tmp+'anat2template.nii.gz', path_output+'anat2template'+ext_data, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(path_tmp+'warp_curve2straight.nii.gz', path_output+'warp_curve2straight.nii.gz', verbose)
sct.generate_output_file(path_tmp+'warp_straight2curve.nii.gz', path_output+'warp_straight2curve.nii.gz', verbose)
sct.generate_output_file(path_tmp+'straight_ref.nii.gz', path_output+'straight_ref.nii.gz', verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.run('rm -rf '+path_tmp)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: '+str(int(round(elapsed_time)))+'s', verbose)
# to view results
sct.printv('\nTo view results, type:', verbose)
sct.printv('fslview '+fname_data+' '+path_output+'template2anat -b 0,4000 &', verbose, 'info')
sct.printv('fslview '+fname_template+' -b 0,5000 '+path_output+'anat2template &\n', verbose, 'info')
def main(args=None):
# initializations
param = Param()
# check user arguments
if not args:
args = sys.argv[1:]
# Get parser info
parser = get_parser()
arguments = parser.parse(args)
fname_data = arguments['-i']
fname_seg = arguments['-s']
if '-l' in arguments:
fname_landmarks = arguments['-l']
label_type = 'body'
elif '-ldisc' in arguments:
fname_landmarks = arguments['-ldisc']
label_type = 'disc'
else:
sct.printv('ERROR: Labels should be provided.', 1, 'error')
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
param.path_qc = arguments.get("-qc", None)
path_template = arguments['-t']
contrast_template = arguments['-c']
ref = arguments['-ref']
param.remove_temp_files = int(arguments.get('-r'))
verbose = int(arguments.get('-v'))
sct.init_sct(log_level=verbose, update=True) # Update log level
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
param.straighten_fitting = arguments['-straighten-fitting']
# if '-cpu-nb' in arguments:
# arg_cpu = ' -cpu-nb '+str(arguments['-cpu-nb'])
# else:
# arg_cpu = ''
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
zsubsample = param.zsubsample
# retrieve template file names
file_template_vertebral_labeling = get_file_label(os.path.join(path_template, 'template'), 'vertebral labeling')
file_template = get_file_label(os.path.join(path_template, 'template'), contrast_template.upper() + '-weighted template')
file_template_seg = get_file_label(os.path.join(path_template, 'template'), 'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = os.path.join(path_template, 'template', file_template)
fname_template_vertebral_labeling = os.path.join(path_template, 'template', file_template_vertebral_labeling)
fname_template_seg = os.path.join(path_template, 'template', file_template_seg)
fname_template_disc_labeling = os.path.join(path_template, 'template', 'PAM50_label_disc.nii.gz')
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
# sct.printv(arguments)
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: ' + fname_data, verbose)
sct.printv(' Landmarks: ' + fname_landmarks, verbose)
sct.printv(' Segmentation: ' + fname_seg, verbose)
sct.printv(' Path template: ' + path_template, verbose)
sct.printv(' Remove temp files: ' + str(param.remove_temp_files), verbose)
# check input labels
labels = check_labels(fname_landmarks, label_type=label_type)
vertebral_alignment = False
if len(labels) > 2 and label_type == 'disc':
vertebral_alignment = True
path_tmp = sct.tmp_create(basename="register_to_template", verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
Image(fname_data).save(os.path.join(path_tmp, ftmp_data))
Image(fname_seg).save(os.path.join(path_tmp, ftmp_seg))
Image(fname_landmarks).save(os.path.join(path_tmp, ftmp_label))
Image(fname_template).save(os.path.join(path_tmp, ftmp_template))
Image(fname_template_seg).save(os.path.join(path_tmp, ftmp_template_seg))
Image(fname_template_vertebral_labeling).save(os.path.join(path_tmp, ftmp_template_label))
if label_type == 'disc':
Image(fname_template_disc_labeling).save(os.path.join(path_tmp, ftmp_template_label))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Generate labels from template vertebral labeling
if label_type == 'body':
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
ftmp_template_label_, ftmp_template_label = ftmp_template_label, sct.add_suffix(ftmp_template_label, "_body")
sct_label_utils.main(args=['-i', ftmp_template_label_, '-vert-body', '0', '-o', ftmp_template_label])
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
# if only one label is present, force affine transformation to be Tx,Ty,Tz only (no scaling)
if len(labels) == 1:
paramreg.steps['0'].dof = 'Tx_Ty_Tz'
sct.printv('WARNING: Only one label is present. Forcing initial transformation to: ' + paramreg.steps['0'].dof,
1, 'warning')
# Project labels onto the spinal cord centerline because later, an affine transformation is estimated between the
# template's labels (centered in the cord) and the subject's labels (assumed to be centered in the cord).
# If labels are not centered, mis-registration errors are observed (see issue #1826)
ftmp_label = project_labels_on_spinalcord(ftmp_label, ftmp_seg)
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
ftmp_seg_, ftmp_seg = ftmp_seg, sct.add_suffix(ftmp_seg, "_bin")
sct_maths.main(['-i', ftmp_seg_,
'-bin', '0.5',
'-o', ftmp_seg])
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
resample_file(ftmp_data, add_suffix(ftmp_data, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_data = add_suffix(ftmp_data, '_1mm')
resample_file(ftmp_seg, add_suffix(ftmp_seg, '_1mm'), '1.0x1.0x1.0', 'mm', 'linear', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling
# with nearest neighbour can make them disappear.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
if vertebral_alignment:
# cropping the segmentation based on the label coverage to ensure good registration with vertebral alignment
# See https://github.com/neuropoly/spinalcordtoolbox/pull/1669 for details
image_labels = Image(ftmp_label)
coordinates_labels = image_labels.getNonZeroCoordinates(sorting='z')
nx, ny, nz, nt, px, py, pz, pt = image_labels.dim
offset_crop = 10.0 * pz # cropping the image 10 mm above and below the highest and lowest label
cropping_slices = [coordinates_labels[0].z - offset_crop, coordinates_labels[-1].z + offset_crop]
# make sure that the cropping slices do not extend outside of the slice range (issue #1811)
if cropping_slices[0] < 0:
cropping_slices[0] = 0
if cropping_slices[1] > nz:
cropping_slices[1] = nz
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, np.int32(np.round(cropping_slices))),))).save(ftmp_seg)
else:
# if we do not align the vertebral levels, we crop the segmentation from top to bottom
im_seg_rpi = Image(ftmp_seg_)
bottom = 0
for data in msct_image.SlicerOneAxis(im_seg_rpi, "IS"):
if (data != 0).any():
break
bottom += 1
top = im_seg_rpi.data.shape[2]
for data in msct_image.SlicerOneAxis(im_seg_rpi, "SI"):
if (data != 0).any():
break
top -= 1
msct_image.spatial_crop(im_seg_rpi, dict(((2, (bottom, top)),))).save(ftmp_seg)
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
fn_warp_curve2straight = os.path.join(curdir, "warp_curve2straight.nii.gz")
fn_warp_straight2curve = os.path.join(curdir, "warp_straight2curve.nii.gz")
fn_straight_ref = os.path.join(curdir, "straight_ref.nii.gz")
cache_input_files=[ftmp_seg]
if vertebral_alignment:
cache_input_files += [
ftmp_template_seg,
ftmp_label,
ftmp_template_label,
]
cache_sig = sct.cache_signature(
input_files=cache_input_files,
)
cachefile = os.path.join(curdir, "straightening.cache")
if sct.cache_valid(cachefile, cache_sig) and os.path.isfile(fn_warp_curve2straight) and os.path.isfile(fn_warp_straight2curve) and os.path.isfile(fn_straight_ref):
sct.printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
sct.copy(fn_warp_curve2straight, 'warp_curve2straight.nii.gz')
sct.copy(fn_warp_straight2curve, 'warp_straight2curve.nii.gz')
sct.copy(fn_straight_ref, 'straight_ref.nii.gz')
# apply straightening
sct.run(['sct_apply_transfo', '-i', ftmp_seg, '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', add_suffix(ftmp_seg, '_straight')])
else:
from spinalcordtoolbox.straightening import SpinalCordStraightener
sc_straight = SpinalCordStraightener(ftmp_seg, ftmp_seg)
sc_straight.algo_fitting = param.straighten_fitting
sc_straight.output_filename = add_suffix(ftmp_seg, '_straight')
sc_straight.path_output = './'
sc_straight.qc = '0'
sc_straight.remove_temp_files = param.remove_temp_files
sc_straight.verbose = verbose
if vertebral_alignment:
sc_straight.centerline_reference_filename = ftmp_template_seg
sc_straight.use_straight_reference = True
sc_straight.discs_input_filename = ftmp_label
sc_straight.discs_ref_filename = ftmp_template_label
sc_straight.straighten()
sct.cache_save(cachefile, cache_sig)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
s, o = sct.run(['sct_concat_transfo', '-w', 'warp_straight2curve.nii.gz', '-d', ftmp_data, '-o', 'warp_straight2curve.nii.gz'])
if vertebral_alignment:
sct.copy('warp_curve2straight.nii.gz', 'warp_curve2straightAffine.nii.gz')
else:
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct_maths.main(['-i', ftmp_label,
'-dilate', '3',
'-o', add_suffix(ftmp_label, '_dilate')])
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run(['sct_apply_transfo', '-i', ftmp_label, '-o', add_suffix(ftmp_label, '_straight'), '-d', add_suffix(ftmp_seg, '_straight'), '-w', 'warp_curve2straight.nii.gz', '-x', 'nn'])
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof,
fname_affine='straight2templateAffine.txt', verbose=verbose)
except RuntimeError:
raise('Input labels do not seem to be at the right place. Please check the position of the labels. '
'See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct.run(['sct_concat_transfo', '-w', 'warp_curve2straight.nii.gz,straight2templateAffine.txt', '-d', 'template.nii', '-o', 'warp_curve2straightAffine.nii.gz'])
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run(['sct_apply_transfo', '-i', ftmp_data, '-o', add_suffix(ftmp_data, '_straightAffine'), '-d', ftmp_template, '-w', 'warp_curve2straightAffine.nii.gz'])
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run(['sct_apply_transfo', '-i', ftmp_seg, '-o', add_suffix(ftmp_seg, '_straightAffine'), '-d', ftmp_template, '-w', 'warp_curve2straightAffine.nii.gz', '-x', 'linear'])
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(np.round(np.min(points_straight))), int(np.round(np.max(points_straight)))
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_black')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (min_point,max_point)),))).save(ftmp_seg)
"""
# open segmentation
im = Image(ftmp_seg)
im_new = msct_image.empty_like(im)
# binarize
im_new.data = im.data > 0.5
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = msct_image.find_zmin_zmax(im_new, threshold=0.5)
# save binarized segmentation
im_new.save(add_suffix(ftmp_seg, '_bin')) # unused?
# crop template in z-direction (for faster processing)
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
ftmp_template_, ftmp_template = ftmp_template, add_suffix(ftmp_template, '_crop')
msct_image.spatial_crop(Image(ftmp_template_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template)
ftmp_template_seg_, ftmp_template_seg = ftmp_template_seg, add_suffix(ftmp_template_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_template_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_template_seg)
ftmp_data_, ftmp_data = ftmp_data, add_suffix(ftmp_data, '_crop')
msct_image.spatial_crop(Image(ftmp_data_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_data)
ftmp_seg_, ftmp_seg = ftmp_seg, add_suffix(ftmp_seg, '_crop')
msct_image.spatial_crop(Image(ftmp_seg_), dict(((2, (zmin_template,zmax_template)),))).save(ftmp_seg)
# sub-sample in z-direction
# TODO: refactor to use python module instead of doing i/o
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run(['sct_resample', '-i', ftmp_template, '-o', add_suffix(ftmp_template, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run(['sct_resample', '-i', ftmp_template_seg, '-o', add_suffix(ftmp_template_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run(['sct_resample', '-i', ftmp_data, '-o', add_suffix(ftmp_data, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run(['sct_resample', '-i', ftmp_seg, '-o', add_suffix(ftmp_seg, '_sub'), '-f', '1x1x' + zsubsample], verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog':
src_seg = ftmp_seg
dest_seg = ftmp_template_seg
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# apply transformation from previous step, to use as new src for registration
sct.run(['sct_apply_transfo', '-i', src, '-d', dest, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # also apply transformation to the seg
sct.run(['sct_apply_transfo', '-i', src_seg, '-d', dest_seg, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src_seg = add_suffix(src_seg, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
if paramreg.steps[str(i_step)].algo == 'centermassrot' and paramreg.steps[str(i_step)].rot_method == 'hog': # im_seg case
warp_forward_out, warp_inverse_out = register([src, src_seg], [dest, dest_seg], paramreg, param, str(i_step))
else:
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
sct.run(['sct_concat_transfo', '-w', 'warp_curve2straightAffine.nii.gz,' + ','.join(warp_forward), '-d', 'template.nii', '-o', 'warp_anat2template.nii.gz'], verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
if vertebral_alignment:
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse) + ',warp_straight2curve.nii.gz', '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
else:
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse) + ',-straight2templateAffine.txt,warp_straight2curve.nii.gz', '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
ftmp_data = Image(ftmp_data).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_seg = Image(ftmp_seg).change_orientation("RPI", generate_path=True).save().absolutepath
ftmp_label = Image(ftmp_label).change_orientation("RPI", generate_path=True).save().absolutepath
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run(['sct_label_utils', '-i', ftmp_template_label, '-o', ftmp_template_label, '-remove-reference', ftmp_label])
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This
# new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = np.round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[int(new_label.x), int(new_label.y), int(new_label.z)] = new_label.value
# Overwrite label file
# im_label.absolutepath = 'label_rpi_modif.nii.gz'
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc="./")
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://www.slideshare.net/neuropoly/sct-course-20190121/42', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #' + str(i_step) + '...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run(['sct_apply_transfo', '-i', src, '-d', dest, '-w', ','.join(warp_forward), '-o', add_suffix(src, '_regStep' + str(i_step - 1)), '-x', interp_step], verbose)
src = add_suffix(src, '_regStep' + str(i_step - 1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_forward), '-d', 'data.nii', '-o', 'warp_template2anat.nii.gz'], verbose)
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct.run(['sct_concat_transfo', '-w', ','.join(warp_inverse), '-d', 'template.nii', '-o', 'warp_anat2template.nii.gz'], verbose)
# Apply warping fields to anat and template
sct.run(['sct_apply_transfo', '-i', 'template.nii', '-o', 'template2anat.nii.gz', '-d', 'data.nii', '-w', 'warp_template2anat.nii.gz', '-crop', '1'], verbose)
sct.run(['sct_apply_transfo', '-i', 'data.nii', '-o', 'anat2template.nii.gz', '-d', 'template.nii', '-w', 'warp_anat2template.nii.gz', '-crop', '1'], verbose)
# come back
os.chdir(curdir)
# Generate output files
sct.printv('\nGenerate output files...', verbose)
fname_template2anat = os.path.join(path_output, 'template2anat' + ext_data)
fname_anat2template = os.path.join(path_output, 'anat2template' + ext_data)
sct.generate_output_file(os.path.join(path_tmp, "warp_template2anat.nii.gz"), os.path.join(path_output, "warp_template2anat.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_anat2template.nii.gz"), os.path.join(path_output, "warp_anat2template.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "template2anat.nii.gz"), fname_template2anat, verbose)
sct.generate_output_file(os.path.join(path_tmp, "anat2template.nii.gz"), fname_anat2template, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"), os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"), os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose)
sct.generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"), os.path.join(path_output, "straight_ref.nii.gz"), verbose)
# Delete temporary files
if param.remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.rmtree(path_tmp, verbose=verbose)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's', verbose)
qc_dataset = arguments.get("-qc-dataset", None)
qc_subject = arguments.get("-qc-subject", None)
if param.path_qc is not None:
generate_qc(fname_data, fname_in2=fname_template2anat, fname_seg=fname_seg, args=args,
path_qc=os.path.abspath(param.path_qc), dataset=qc_dataset, subject=qc_subject,
process='sct_register_to_template')
sct.display_viewer_syntax([fname_data, fname_template2anat], verbose=verbose)
sct.display_viewer_syntax([fname_template, fname_anat2template], verbose=verbose)
def main():
parser = get_parser()
param = Param()
arguments = parser.parse(sys.argv[1:])
# get arguments
fname_data = arguments['-i']
fname_seg = arguments['-s']
fname_landmarks = arguments['-l']
if '-ofolder' in arguments:
path_output = arguments['-ofolder']
else:
path_output = ''
path_template = sct.slash_at_the_end(arguments['-t'], 1)
contrast_template = arguments['-c']
ref = arguments['-ref']
remove_temp_files = int(arguments['-r'])
verbose = int(arguments['-v'])
param.verbose = verbose # TODO: not clean, unify verbose or param.verbose in code, but not both
if '-param-straighten' in arguments:
param.param_straighten = arguments['-param-straighten']
# if '-cpu-nb' in arguments:
# arg_cpu = ' -cpu-nb '+str(arguments['-cpu-nb'])
# else:
# arg_cpu = ''
# registration parameters
if '-param' in arguments:
# reset parameters but keep step=0 (might be overwritten if user specified step=0)
paramreg = ParamregMultiStep([step0])
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# add user parameters
for paramStep in arguments['-param']:
paramreg.addStep(paramStep)
else:
paramreg = ParamregMultiStep([step0, step1, step2])
# if ref=subject, initialize registration using different affine parameters
if ref == 'subject':
paramreg.steps['0'].dof = 'Tx_Ty_Tz_Rx_Ry_Rz_Sz'
# initialize other parameters
# file_template_label = param.file_template_label
zsubsample = param.zsubsample
template = os.path.basename(os.path.normpath(path_template))
# smoothing_sigma = param.smoothing_sigma
# retrieve template file names
from sct_warp_template import get_file_label
file_template_vertebral_labeling = get_file_label(path_template+'template/', 'vertebral')
file_template = get_file_label(path_template+'template/', contrast_template.upper()+'-weighted')
file_template_seg = get_file_label(path_template+'template/', 'spinal cord')
# start timer
start_time = time.time()
# get fname of the template + template objects
fname_template = path_template+'template/'+file_template
fname_template_vertebral_labeling = path_template+'template/'+file_template_vertebral_labeling
fname_template_seg = path_template+'template/'+file_template_seg
# check file existence
# TODO: no need to do that!
sct.printv('\nCheck template files...')
sct.check_file_exist(fname_template, verbose)
sct.check_file_exist(fname_template_vertebral_labeling, verbose)
sct.check_file_exist(fname_template_seg, verbose)
# print arguments
sct.printv('\nCheck parameters:', verbose)
sct.printv(' Data: '+fname_data, verbose)
sct.printv(' Landmarks: '+fname_landmarks, verbose)
sct.printv(' Segmentation: '+fname_seg, verbose)
sct.printv(' Path template: '+path_template, verbose)
sct.printv(' Remove temp files: '+str(remove_temp_files), verbose)
# create QC folder
sct.create_folder(param.path_qc)
#
# sct.printv('\nParameters for registration:')
# for pStep in range(0, len(paramreg.steps)):
# sct.printv('Step #'+paramreg.steps[str(pStep)].step, verbose)
# sct.printv(' Type .................... '+paramreg.steps[str(pStep)].type, verbose)
# sct.printv(' Algorithm ............... '+paramreg.steps[str(pStep)].algo, verbose)
# sct.printv(' Metric .................. '+paramreg.steps[str(pStep)].metric, verbose)
# sct.printv(' Number of iterations .... '+paramreg.steps[str(pStep)].iter, verbose)
# sct.printv(' Shrink factor ........... '+paramreg.steps[str(pStep)].shrink, verbose)
# sct.printv(' Smoothing factor......... '+paramreg.steps[str(pStep)].smooth, verbose)
# sct.printv(' Gradient step ........... '+paramreg.steps[str(pStep)].gradStep, verbose)
# sct.printv(' Degree of polynomial .... '+paramreg.steps[str(pStep)].poly, verbose)
path_data, file_data, ext_data = sct.extract_fname(fname_data)
sct.printv('\nCheck if data, segmentation and landmarks are in the same space...')
if not sct.check_if_same_space(fname_data, fname_seg):
sct.printv('ERROR: Data image and segmentation are not in the same space. Please check space and orientation of your files', verbose, 'error')
if not sct.check_if_same_space(fname_data, fname_landmarks):
sct.printv('ERROR: Data image and landmarks are not in the same space. Please check space and orientation of your files', verbose, 'error')
sct.printv('\nCheck input labels...')
# check if label image contains coherent labels
image_label = Image(fname_landmarks)
# -> all labels must be different
labels = image_label.getNonZeroCoordinates(sorting='value')
hasDifferentLabels = True
for lab in labels:
for otherlabel in labels:
if lab != otherlabel and lab.hasEqualValue(otherlabel):
hasDifferentLabels = False
break
if not hasDifferentLabels:
sct.printv('ERROR: Wrong landmarks input. All labels must be different.', verbose, 'error')
# create temporary folder
path_tmp = sct.tmp_create(verbose=verbose)
# set temporary file names
ftmp_data = 'data.nii'
ftmp_seg = 'seg.nii.gz'
ftmp_label = 'label.nii.gz'
ftmp_template = 'template.nii'
ftmp_template_seg = 'template_seg.nii.gz'
ftmp_template_label = 'template_label.nii.gz'
# copy files to temporary folder
sct.printv('\nCopying input data to tmp folder and convert to nii...', verbose)
sct.run('sct_convert -i '+fname_data+' -o '+path_tmp+ftmp_data)
sct.run('sct_convert -i '+fname_seg+' -o '+path_tmp+ftmp_seg)
sct.run('sct_convert -i '+fname_landmarks+' -o '+path_tmp+ftmp_label)
sct.run('sct_convert -i '+fname_template+' -o '+path_tmp+ftmp_template)
sct.run('sct_convert -i '+fname_template_seg+' -o '+path_tmp+ftmp_template_seg)
# sct.run('sct_convert -i '+fname_template_label+' -o '+path_tmp+ftmp_template_label)
# go to tmp folder
os.chdir(path_tmp)
# Generate labels from template vertebral labeling
sct.printv('\nGenerate labels from template vertebral labeling', verbose)
sct.run('sct_label_utils -i '+fname_template_vertebral_labeling+' -vert-body 0 -o '+ftmp_template_label)
# check if provided labels are available in the template
sct.printv('\nCheck if provided labels are available in the template', verbose)
image_label_template = Image(ftmp_template_label)
labels_template = image_label_template.getNonZeroCoordinates(sorting='value')
if labels[-1].value > labels_template[-1].value:
sct.printv('ERROR: Wrong landmarks input. Labels must have correspondence in template space. \nLabel max '
'provided: ' + str(labels[-1].value) + '\nLabel max from template: ' +
str(labels_template[-1].value), verbose, 'error')
# binarize segmentation (in case it has values below 0 caused by manual editing)
sct.printv('\nBinarize segmentation', verbose)
sct.run('sct_maths -i seg.nii.gz -bin 0.5 -o seg.nii.gz')
# smooth segmentation (jcohenadad, issue #613)
# sct.printv('\nSmooth segmentation...', verbose)
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 1.5 -o '+add_suffix(ftmp_seg, '_smooth'))
# jcohenadad: updated 2016-06-16: DO NOT smooth the seg anymore. Issue #
# sct.run('sct_maths -i '+ftmp_seg+' -smooth 0 -o '+add_suffix(ftmp_seg, '_smooth'))
# ftmp_seg = add_suffix(ftmp_seg, '_smooth')
# Switch between modes: subject->template or template->subject
if ref == 'template':
# resample data to 1mm isotropic
sct.printv('\nResample data to 1mm isotropic...', verbose)
sct.run('sct_resample -i '+ftmp_data+' -mm 1.0x1.0x1.0 -x linear -o '+add_suffix(ftmp_data, '_1mm'))
ftmp_data = add_suffix(ftmp_data, '_1mm')
sct.run('sct_resample -i '+ftmp_seg+' -mm 1.0x1.0x1.0 -x linear -o '+add_suffix(ftmp_seg, '_1mm'))
ftmp_seg = add_suffix(ftmp_seg, '_1mm')
# N.B. resampling of labels is more complicated, because they are single-point labels, therefore resampling with neighrest neighbour can make them disappear. Therefore a more clever approach is required.
resample_labels(ftmp_label, ftmp_data, add_suffix(ftmp_label, '_1mm'))
ftmp_label = add_suffix(ftmp_label, '_1mm')
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i '+ftmp_data+' -setorient RPI -o '+add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i '+ftmp_seg+' -setorient RPI -o '+add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i '+ftmp_label+' -setorient RPI -o '+add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# get landmarks in native space
# crop segmentation
# output: segmentation_rpi_crop.nii.gz
status_crop, output_crop = sct.run('sct_crop_image -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_crop')+' -dim 2 -bzmax', verbose)
ftmp_seg = add_suffix(ftmp_seg, '_crop')
cropping_slices = output_crop.split('Dimension 2: ')[1].split('\n')[0].split(' ')
# straighten segmentation
sct.printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
if os.path.isfile('../warp_curve2straight.nii.gz') and os.path.isfile('../warp_straight2curve.nii.gz') and os.path.isfile('../straight_ref.nii.gz'):
# if they exist, copy them into current folder
sct.printv('WARNING: Straightening was already run previously. Copying warping fields...', verbose, 'warning')
shutil.copy('../warp_curve2straight.nii.gz', 'warp_curve2straight.nii.gz')
shutil.copy('../warp_straight2curve.nii.gz', 'warp_straight2curve.nii.gz')
shutil.copy('../straight_ref.nii.gz', 'straight_ref.nii.gz')
# apply straightening
sct.run('sct_apply_transfo -i '+ftmp_seg+' -w warp_curve2straight.nii.gz -d straight_ref.nii.gz -o '+add_suffix(ftmp_seg, '_straight'))
else:
sct.run('sct_straighten_spinalcord -i '+ftmp_seg+' -s '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_straight')+' -qc 0 -r 0 -v '+str(verbose), verbose)
# N.B. DO NOT UPDATE VARIABLE ftmp_seg BECAUSE TEMPORARY USED LATER
# re-define warping field using non-cropped space (to avoid issue #367)
sct.run('sct_concat_transfo -w warp_straight2curve.nii.gz -d '+ftmp_data+' -o warp_straight2curve.nii.gz')
# Label preparation:
# --------------------------------------------------------------------------------
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i '+ftmp_template_label+' -o '+ftmp_template_label+' -remove '+ftmp_label)
# Dilating the input label so they can be straighten without losing them
sct.printv('\nDilating input labels using 3vox ball radius')
sct.run('sct_maths -i '+ftmp_label+' -o '+add_suffix(ftmp_label, '_dilate')+' -dilate 3')
ftmp_label = add_suffix(ftmp_label, '_dilate')
# Apply straightening to labels
sct.printv('\nApply straightening to labels...', verbose)
sct.run('sct_apply_transfo -i '+ftmp_label+' -o '+add_suffix(ftmp_label, '_straight')+' -d '+add_suffix(ftmp_seg, '_straight')+' -w warp_curve2straight.nii.gz -x nn')
ftmp_label = add_suffix(ftmp_label, '_straight')
# Compute rigid transformation straight landmarks --> template landmarks
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
try:
register_landmarks(ftmp_label, ftmp_template_label, paramreg.steps['0'].dof, fname_affine='straight2templateAffine.txt', verbose=verbose)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# Concatenate transformations: curve --> straight --> affine
sct.printv('\nConcatenate transformations: curve --> straight --> affine...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt -d template.nii -o warp_curve2straightAffine.nii.gz')
# Apply transformation
sct.printv('\nApply transformation...', verbose)
sct.run('sct_apply_transfo -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_straightAffine')+' -d '+ftmp_template+' -w warp_curve2straightAffine.nii.gz')
ftmp_data = add_suffix(ftmp_data, '_straightAffine')
sct.run('sct_apply_transfo -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_straightAffine')+' -d '+ftmp_template+' -w warp_curve2straightAffine.nii.gz -x linear')
ftmp_seg = add_suffix(ftmp_seg, '_straightAffine')
"""
# Benjamin: Issue from Allan Martin, about the z=0 slice that is screwed up, caused by the affine transform.
# Solution found: remove slices below and above landmarks to avoid rotation effects
points_straight = []
for coord in landmark_template:
points_straight.append(coord.z)
min_point, max_point = int(round(np.min(points_straight))), int(round(np.max(points_straight)))
sct.run('sct_crop_image -i ' + ftmp_seg + ' -start ' + str(min_point) + ' -end ' + str(max_point) + ' -dim 2 -b 0 -o ' + add_suffix(ftmp_seg, '_black'))
ftmp_seg = add_suffix(ftmp_seg, '_black')
"""
# binarize
sct.printv('\nBinarize segmentation...', verbose)
sct.run('sct_maths -i '+ftmp_seg+' -bin 0.5 -o '+add_suffix(ftmp_seg, '_bin'))
ftmp_seg = add_suffix(ftmp_seg, '_bin')
# find min-max of anat2template (for subsequent cropping)
zmin_template, zmax_template = find_zmin_zmax(ftmp_seg)
# crop template in z-direction (for faster processing)
sct.printv('\nCrop data in template space (for faster processing)...', verbose)
sct.run('sct_crop_image -i '+ftmp_template+' -o '+add_suffix(ftmp_template, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_template = add_suffix(ftmp_template, '_crop')
sct.run('sct_crop_image -i '+ftmp_template_seg+' -o '+add_suffix(ftmp_template_seg, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_template_seg = add_suffix(ftmp_template_seg, '_crop')
sct.run('sct_crop_image -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_data = add_suffix(ftmp_data, '_crop')
sct.run('sct_crop_image -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_crop')+' -dim 2 -start '+str(zmin_template)+' -end '+str(zmax_template))
ftmp_seg = add_suffix(ftmp_seg, '_crop')
# sub-sample in z-direction
sct.printv('\nSub-sample in z-direction (for faster processing)...', verbose)
sct.run('sct_resample -i '+ftmp_template+' -o '+add_suffix(ftmp_template, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_template = add_suffix(ftmp_template, '_sub')
sct.run('sct_resample -i '+ftmp_template_seg+' -o '+add_suffix(ftmp_template_seg, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_template_seg = add_suffix(ftmp_template_seg, '_sub')
sct.run('sct_resample -i '+ftmp_data+' -o '+add_suffix(ftmp_data, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_data = add_suffix(ftmp_data, '_sub')
sct.run('sct_resample -i '+ftmp_seg+' -o '+add_suffix(ftmp_seg, '_sub')+' -f 1x1x'+zsubsample, verbose)
ftmp_seg = add_suffix(ftmp_seg, '_sub')
# Registration straight spinal cord to template
sct.printv('\nRegister straight spinal cord to template...', verbose)
# loop across registration steps
warp_forward = []
warp_inverse = []
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #'+str(i_step)+'...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_data
dest = ftmp_template
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_seg
dest = ftmp_template_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# if step>1, apply warp_forward_concat to the src image to be used
if i_step > 1:
# sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+sct.add_suffix(src, '_reg')+' -x '+interp_step, verbose)
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+add_suffix(src, '_regStep'+str(i_step-1))+' -x '+interp_step, verbose)
src = add_suffix(src, '_regStep'+str(i_step-1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.append(warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: anat --> template...', verbose)
sct.run('sct_concat_transfo -w warp_curve2straightAffine.nii.gz,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
# sct.run('sct_concat_transfo -w warp_curve2straight.nii.gz,straight2templateAffine.txt,'+','.join(warp_forward)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
sct.printv('\nConcatenate transformations: template --> anat...', verbose)
warp_inverse.reverse()
sct.run('sct_concat_transfo -w '+','.join(warp_inverse)+',-straight2templateAffine.txt,warp_straight2curve.nii.gz -d data.nii -o warp_template2anat.nii.gz', verbose)
# register template->subject
elif ref == 'subject':
# Change orientation of input images to RPI
sct.printv('\nChange orientation of input images to RPI...', verbose)
sct.run('sct_image -i ' + ftmp_data + ' -setorient RPI -o ' + add_suffix(ftmp_data, '_rpi'))
ftmp_data = add_suffix(ftmp_data, '_rpi')
sct.run('sct_image -i ' + ftmp_seg + ' -setorient RPI -o ' + add_suffix(ftmp_seg, '_rpi'))
ftmp_seg = add_suffix(ftmp_seg, '_rpi')
sct.run('sct_image -i ' + ftmp_label + ' -setorient RPI -o ' + add_suffix(ftmp_label, '_rpi'))
ftmp_label = add_suffix(ftmp_label, '_rpi')
# Remove unused label on template. Keep only label present in the input label image
sct.printv('\nRemove unused label on template. Keep only label present in the input label image...', verbose)
sct.run('sct_label_utils -i '+ftmp_template_label+' -o '+ftmp_template_label+' -remove '+ftmp_label)
# Add one label because at least 3 orthogonal labels are required to estimate an affine transformation. This new label is added at the level of the upper most label (lowest value), at 1cm to the right.
for i_file in [ftmp_label, ftmp_template_label]:
im_label = Image(i_file)
coord_label = im_label.getCoordinatesAveragedByValue() # N.B. landmarks are sorted by value
# Create new label
from copy import deepcopy
new_label = deepcopy(coord_label[0])
# move it 5mm to the left (orientation is RAS)
nx, ny, nz, nt, px, py, pz, pt = im_label.dim
new_label.x = round(coord_label[0].x + 5.0 / px)
# assign value 99
new_label.value = 99
# Add to existing image
im_label.data[new_label.x, new_label.y, new_label.z] = new_label.value
# Overwrite label file
# im_label.setFileName('label_rpi_modif.nii.gz')
im_label.save()
# Bring template to subject space using landmark-based transformation
sct.printv('\nEstimate transformation for step #0...', verbose)
from msct_register_landmarks import register_landmarks
warp_forward = ['template2subjectAffine.txt']
warp_inverse = ['-template2subjectAffine.txt']
try:
register_landmarks(ftmp_template_label, ftmp_label, paramreg.steps['0'].dof, fname_affine=warp_forward[0], verbose=verbose, path_qc=param.path_qc)
except Exception:
sct.printv('ERROR: input labels do not seem to be at the right place. Please check the position of the labels. See documentation for more details: https://sourceforge.net/p/spinalcordtoolbox/wiki/create_labels/', verbose=verbose, type='error')
# loop across registration steps
for i_step in range(1, len(paramreg.steps)):
sct.printv('\nEstimate transformation for step #'+str(i_step)+'...', verbose)
# identify which is the src and dest
if paramreg.steps[str(i_step)].type == 'im':
src = ftmp_template
dest = ftmp_data
interp_step = 'linear'
elif paramreg.steps[str(i_step)].type == 'seg':
src = ftmp_template_seg
dest = ftmp_seg
interp_step = 'nn'
else:
sct.printv('ERROR: Wrong image type.', 1, 'error')
# apply transformation from previous step, to use as new src for registration
sct.run('sct_apply_transfo -i '+src+' -d '+dest+' -w '+','.join(warp_forward)+' -o '+add_suffix(src, '_regStep'+str(i_step-1))+' -x '+interp_step, verbose)
src = add_suffix(src, '_regStep'+str(i_step-1))
# register src --> dest
# TODO: display param for debugging
warp_forward_out, warp_inverse_out = register(src, dest, paramreg, param, str(i_step))
warp_forward.append(warp_forward_out)
warp_inverse.insert(0, warp_inverse_out)
# Concatenate transformations:
sct.printv('\nConcatenate transformations: template --> subject...', verbose)
sct.run('sct_concat_transfo -w '+','.join(warp_forward)+' -d data.nii -o warp_template2anat.nii.gz', verbose)
sct.printv('\nConcatenate transformations: subject --> template...', verbose)
sct.run('sct_concat_transfo -w '+','.join(warp_inverse)+' -d template.nii -o warp_anat2template.nii.gz', verbose)
# Apply warping fields to anat and template
sct.run('sct_apply_transfo -i template.nii -o template2anat.nii.gz -d data.nii -w warp_template2anat.nii.gz -crop 1', verbose)
sct.run('sct_apply_transfo -i data.nii -o anat2template.nii.gz -d template.nii -w warp_anat2template.nii.gz -crop 1', verbose)
# come back to parent folder
os.chdir('..')
# Generate output files
sct.printv('\nGenerate output files...', verbose)
sct.generate_output_file(path_tmp+'warp_template2anat.nii.gz', path_output+'warp_template2anat.nii.gz', verbose)
sct.generate_output_file(path_tmp+'warp_anat2template.nii.gz', path_output+'warp_anat2template.nii.gz', verbose)
sct.generate_output_file(path_tmp+'template2anat.nii.gz', path_output+'template2anat'+ext_data, verbose)
sct.generate_output_file(path_tmp+'anat2template.nii.gz', path_output+'anat2template'+ext_data, verbose)
if ref == 'template':
# copy straightening files in case subsequent SCT functions need them
sct.generate_output_file(path_tmp+'warp_curve2straight.nii.gz', path_output+'warp_curve2straight.nii.gz', verbose)
sct.generate_output_file(path_tmp+'warp_straight2curve.nii.gz', path_output+'warp_straight2curve.nii.gz', verbose)
sct.generate_output_file(path_tmp+'straight_ref.nii.gz', path_output+'straight_ref.nii.gz', verbose)
# Delete temporary files
if remove_temp_files:
sct.printv('\nDelete temporary files...', verbose)
sct.run('rm -rf '+path_tmp)
# display elapsed time
elapsed_time = time.time() - start_time
sct.printv('\nFinished! Elapsed time: '+str(int(round(elapsed_time)))+'s', verbose)
# to view results
sct.printv('\nTo view results, type:', verbose)
sct.printv('fslview '+fname_data+' '+path_output+'template2anat -b 0,4000 &', verbose, 'info')
sct.printv('fslview '+fname_template+' -b 0,5000 '+path_output+'anat2template &\n', verbose, 'info')
def register(src, dest, paramreg, param, i_step_str):
# initiate default parameters of antsRegistration transformation
ants_registration_params = {'rigid': '', 'affine': '', 'compositeaffine': '', 'similarity': '', 'translation': '',
'bspline': ',10', 'gaussiandisplacementfield': ',3,0',
'bsplinedisplacementfield': ',5,10', 'syn': ',3,0', 'bsplinesyn': ',1,3'}
output = '' # default output if problem
if paramreg.steps[i_step_str].algo == "centermassrot" and paramreg.steps[i_step_str].rot_method == 'hog':
src_im = src[0] # user is expected to input images to src and dest
dest_im = dest[0]
src_seg = src[1]
dest_seg = dest[1]
del src
del dest # to be sure it is not missused later
# display arguments
sct.printv('Registration parameters:', param.verbose)
sct.printv(' type ........... ' + paramreg.steps[i_step_str].type, param.verbose)
sct.printv(' algo ........... ' + paramreg.steps[i_step_str].algo, param.verbose)
sct.printv(' slicewise ...... ' + paramreg.steps[i_step_str].slicewise, param.verbose)
sct.printv(' metric ......... ' + paramreg.steps[i_step_str].metric, param.verbose)
sct.printv(' iter ........... ' + paramreg.steps[i_step_str].iter, param.verbose)
sct.printv(' smooth ......... ' + paramreg.steps[i_step_str].smooth, param.verbose)
sct.printv(' laplacian ...... ' + paramreg.steps[i_step_str].laplacian, param.verbose)
sct.printv(' shrink ......... ' + paramreg.steps[i_step_str].shrink, param.verbose)
sct.printv(' gradStep ....... ' + paramreg.steps[i_step_str].gradStep, param.verbose)
sct.printv(' deformation .... ' + paramreg.steps[i_step_str].deformation, param.verbose)
sct.printv(' init ........... ' + paramreg.steps[i_step_str].init, param.verbose)
sct.printv(' poly ........... ' + paramreg.steps[i_step_str].poly, param.verbose)
sct.printv(' dof ............ ' + paramreg.steps[i_step_str].dof, param.verbose)
sct.printv(' smoothWarpXY ... ' + paramreg.steps[i_step_str].smoothWarpXY, param.verbose)
sct.printv(' rot_method ... ' + paramreg.steps[i_step_str].rot_method, param.verbose)
# set metricSize
if paramreg.steps[i_step_str].metric == 'MI':
metricSize = '32' # corresponds to number of bins
else:
metricSize = '4' # corresponds to radius (for CC, MeanSquares...)
# set masking
if param.fname_mask:
fname_mask = 'mask.nii.gz'
masking = ['-x', 'mask.nii.gz']
else:
fname_mask = ''
masking = []
if paramreg.steps[i_step_str].algo == 'slicereg':
# check if user used type=label
if paramreg.steps[i_step_str].type == 'label':
sct.printv('\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg', 1,
'error')
else:
# Find the min (and max) z-slice index below which (and above which) slices only have voxels below a given
# threshold.
list_fname = [src, dest]
if not masking == []:
list_fname.append(fname_mask)
zmin_global, zmax_global = 0, 99999 # this is assuming that typical image has less slice than 99999
for fname in list_fname:
im = Image(fname)
zmin, zmax = msct_image.find_zmin_zmax(im, threshold=0.1)
if zmin > zmin_global:
zmin_global = zmin
if zmax < zmax_global:
zmax_global = zmax
# crop images (see issue #293)
src_crop = sct.add_suffix(src, '_crop')
msct_image.spatial_crop(Image(src), dict(((2, (zmin_global, zmax_global)),))).save(src_crop)
dest_crop = sct.add_suffix(dest, '_crop')
msct_image.spatial_crop(Image(dest), dict(((2, (zmin_global, zmax_global)),))).save(dest_crop)
# update variables
src = src_crop
dest = dest_crop
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
# estimate transfo
# TODO fixup isct_ants* parsers
cmd = ['isct_antsSliceRegularizedRegistration',
'-t', 'Translation[' + paramreg.steps[i_step_str].gradStep + ']',
'-m',
paramreg.steps[i_step_str].metric + '[' + dest + ',' + src + ',1,' + metricSize + ',Regular,0.2]',
'-p', paramreg.steps[i_step_str].poly,
'-i', paramreg.steps[i_step_str].iter,
'-f', paramreg.steps[i_step_str].shrink,
'-s', paramreg.steps[i_step_str].smooth,
'-v', '1', # verbose (verbose=2 does not exist, so we force it to 1)
'-o', '[step' + i_step_str + ',' + scr_regStep + ']', # here the warp name is stage10 because
# antsSliceReg add "Warp"
] + masking
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
# run command
status, output = sct.run(cmd, param.verbose, is_sct_binary=True)
# ANTS 3d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params \
and paramreg.steps[i_step_str].slicewise == '0':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
# Pad the destination image (because ants doesn't deform the extremities)
# N.B. no need to pad if iter = 0
if not paramreg.steps[i_step_str].iter == '0':
dest_pad = sct.add_suffix(dest, '_pad')
sct.run(['sct_image', '-i', dest, '-o', dest_pad, '-pad', '0,0,' + str(param.padding)])
dest = dest_pad
# apply Laplacian filter
if not paramreg.steps[i_step_str].laplacian == '0':
sct.printv('\nApply Laplacian filter', param.verbose)
sct.run(['sct_maths', '-i', src, '-laplacian', paramreg.steps[i_step_str].laplacian + ','
+ paramreg.steps[i_step_str].laplacian + ',0', '-o', sct.add_suffix(src, '_laplacian')])
sct.run(['sct_maths', '-i', dest, '-laplacian', paramreg.steps[i_step_str].laplacian + ','
+ paramreg.steps[i_step_str].laplacian + ',0', '-o', sct.add_suffix(dest, '_laplacian')])
src = sct.add_suffix(src, '_laplacian')
dest = sct.add_suffix(dest, '_laplacian')
# Estimate transformation
sct.printv('\nEstimate transformation', param.verbose)
scr_regStep = sct.add_suffix(src, '_regStep' + i_step_str)
# TODO fixup isct_ants* parsers
cmd = ['isct_antsRegistration',
'--dimensionality', '3',
'--transform', paramreg.steps[i_step_str].algo + '[' + paramreg.steps[i_step_str].gradStep
+ ants_registration_params[paramreg.steps[i_step_str].algo.lower()] + ']',
'--metric', paramreg.steps[i_step_str].metric + '[' + dest + ',' + src + ',1,' + metricSize + ']',
'--convergence', paramreg.steps[i_step_str].iter,
'--shrink-factors', paramreg.steps[i_step_str].shrink,
'--smoothing-sigmas', paramreg.steps[i_step_str].smooth + 'mm',
'--restrict-deformation', paramreg.steps[i_step_str].deformation,
'--output', '[step' + i_step_str + ',' + scr_regStep + ']',
'--interpolation', 'BSpline[3]',
'--verbose', '1',
] + masking
# add init translation
if not paramreg.steps[i_step_str].init == '':
init_dict = {'geometric': '0', 'centermass': '1', 'origin': '2'}
cmd += ['-r', '[' + dest + ',' + src + ',' + init_dict[paramreg.steps[i_step_str].init] + ']']
# run command
status, output = sct.run(cmd, param.verbose, is_sct_binary=True)
# get appropriate file name for transformation
if paramreg.steps[i_step_str].algo in ['rigid', 'affine', 'translation']:
warp_forward_out = 'step' + i_step_str + '0GenericAffine.mat'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.mat'
else:
warp_forward_out = 'step' + i_step_str + '0Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + '0InverseWarp.nii.gz'
# ANTS 2d
elif paramreg.steps[i_step_str].algo.lower() in ants_registration_params \
and paramreg.steps[i_step_str].slicewise == '1':
# make sure type!=label. If type==label, this will be addressed later in the code.
if not paramreg.steps[i_step_str].type == 'label':
from msct_register import register_slicewise
# if shrink!=1, force it to be 1 (otherwise, it generates a wrong 3d warping field). TODO: fix that!
if not paramreg.steps[i_step_str].shrink == '1':
sct.printv('\nWARNING: when using slicewise with SyN or BSplineSyN, shrink factor needs to be one. '
'Forcing shrink=1.', 1, 'warning')
paramreg.steps[i_step_str].shrink = '1'
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
remove_temp_files=param.remove_temp_files,
verbose=param.verbose)
# slice-wise transfo
elif paramreg.steps[i_step_str].algo in ['centermass', 'centermassrot', 'columnwise']:
# if type=label, exit with error
if paramreg.steps[i_step_str].type == 'label':
sct.printv('\nERROR: this algo is not compatible with type=label. Please use type=im or type=seg', 1,
'error')
# check if user provided a mask-- if so, inform it will be ignored
if not fname_mask == '':
sct.printv('\nWARNING: algo ' + paramreg.steps[i_step_str].algo + ' will ignore the provided mask.\n', 1,
'warning')
# smooth data
if not paramreg.steps[i_step_str].smooth == '0':
sct.printv('\nSmooth data', param.verbose)
if paramreg.steps[i_step_str].rot_method == 'pca':
sct.run(['sct_maths', '-i', src, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(src, '_smooth')])
sct.run(['sct_maths', '-i', dest, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(dest, '_smooth')])
src = sct.add_suffix(src, '_smooth')
dest = sct.add_suffix(dest, '_smooth')
else:
sct.run(['sct_maths', '-i', src_im, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(src_im, '_smooth')])
sct.run(['sct_maths', '-i', src_seg, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(src_seg, '_smooth')])
sct.run(['sct_maths', '-i', dest_im, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(dest_im, '_smooth')])
sct.run(['sct_maths', '-i', dest_seg, '-smooth', paramreg.steps[i_step_str].smooth + ','
+ paramreg.steps[i_step_str].smooth + ',0', '-o', sct.add_suffix(dest_seg, '_smooth')])
src_im = sct.add_suffix(src_im, '_smooth')
dest_im = sct.add_suffix(dest_im, '_smooth')
src_seg = sct.add_suffix(src_seg, '_smooth')
dest_seg = sct.add_suffix(dest_seg, '_smooth')
from msct_register import register_slicewise
warp_forward_out = 'step' + i_step_str + 'Warp.nii.gz'
warp_inverse_out = 'step' + i_step_str + 'InverseWarp.nii.gz'
if paramreg.steps[i_step_str].rot_method == 'pca': #because pca is the default choice, also includes no rotation
register_slicewise(src,
dest,
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
remove_temp_files=param.remove_temp_files,
verbose=param.verbose)
elif paramreg.steps[i_step_str].rot_method == 'hog': # im_seg case
register_slicewise([src_im, src_seg],
[dest_im, dest_seg],
paramreg=paramreg.steps[i_step_str],
fname_mask=fname_mask,
warp_forward_out=warp_forward_out,
warp_inverse_out=warp_inverse_out,
ants_registration_params=ants_registration_params,
path_qc=param.path_qc,
remove_temp_files=param.remove_temp_files,
verbose=param.verbose)
else:
raise ValueError("rot_method " + paramreg.steps[i_step_str].rot_method + " does not exist")
else:
sct.printv('\nERROR: algo ' + paramreg.steps[i_step_str].algo + ' does not exist. Exit program\n', 1, 'error')
# landmark-based registration
if paramreg.steps[i_step_str].type in ['label']:
# check if user specified ilabel and dlabel
# TODO
warp_forward_out = 'step' + i_step_str + '0GenericAffine.txt'
warp_inverse_out = '-step' + i_step_str + '0GenericAffine.txt'
from msct_register_landmarks import register_landmarks
register_landmarks(src,
dest,
paramreg.steps[i_step_str].dof,
fname_affine=warp_forward_out,
verbose=param.verbose)
if not os.path.isfile(warp_forward_out):
# no forward warping field for rigid and affine
sct.printv('\nERROR: file ' + warp_forward_out + ' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
elif not os.path.isfile(warp_inverse_out) and \
paramreg.steps[i_step_str].algo not in ['rigid', 'affine', 'translation'] and \
paramreg.steps[i_step_str].type not in ['label']:
# no inverse warping field for rigid and affine
sct.printv('\nERROR: file ' + warp_inverse_out + ' doesn\'t exist (or is not a file).\n' + output +
'\nERROR: ANTs failed. Exit program.\n', 1, 'error')
else:
# rename warping fields
if (paramreg.steps[i_step_str].algo.lower() in ['rigid', 'affine', 'translation'] and
paramreg.steps[i_step_str].slicewise == '0'):
# if ANTs is used with affine/rigid --> outputs .mat file
warp_forward = 'warp_forward_' + i_step_str + '.mat'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.mat'
elif paramreg.steps[i_step_str].type in ['label']:
# if label-based registration is used --> outputs .txt file
warp_forward = 'warp_forward_' + i_step_str + '.txt'
os.rename(warp_forward_out, warp_forward)
warp_inverse = '-warp_forward_' + i_step_str + '.txt'
else:
warp_forward = 'warp_forward_' + i_step_str + '.nii.gz'
warp_inverse = 'warp_inverse_' + i_step_str + '.nii.gz'
os.rename(warp_forward_out, warp_forward)
os.rename(warp_inverse_out, warp_inverse)
return warp_forward, warp_inverse