def main(args=None):
# Initialization
param = Param()
start_time = time.time()
parser = get_parser()
arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
fname_anat = arguments.i
fname_centerline = arguments.s
param.algo_fitting = arguments.algo_fitting
if arguments.smooth is not None:
sigma = arguments.smooth
remove_temp_files = arguments.r
verbose = int(arguments.v)
init_sct(log_level=verbose, update=True) # Update log level
# Display arguments
printv('\nCheck input arguments...')
printv(' Volume to smooth .................. ' + fname_anat)
printv(' Centerline ........................ ' + fname_centerline)
printv(' Sigma (mm) ........................ ' + str(sigma))
printv(' Verbose ........................... ' + str(verbose))
# Check that input is 3D:
nx, ny, nz, nt, px, py, pz, pt = Image(fname_anat).dim
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
if dim == 4:
printv('WARNING: the input image is 4D, please split your image to 3D before smoothing spinalcord using :\n'
'sct_image -i ' + fname_anat + ' -split t -o ' + fname_anat, verbose, 'warning')
printv('4D images not supported, aborting ...', verbose, 'error')
# Extract path/file/extension
path_anat, file_anat, ext_anat = extract_fname(fname_anat)
path_centerline, file_centerline, ext_centerline = extract_fname(fname_centerline)
path_tmp = tmp_create(basename="smooth_spinalcord")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder and convert to nii...', verbose)
copy(fname_anat, os.path.join(path_tmp, "anat" + ext_anat))
copy(fname_centerline, os.path.join(path_tmp, "centerline" + ext_centerline))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# convert to nii format
convert('anat' + ext_anat, 'anat.nii')
convert('centerline' + ext_centerline, 'centerline.nii')
# Change orientation of the input image into RPI
printv('\nOrient input volume to RPI orientation...')
fname_anat_rpi = Image("anat.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Change orientation of the input image into RPI
printv('\nOrient centerline to RPI orientation...')
fname_centerline_rpi = Image("centerline.nii") \
.change_orientation("RPI", generate_path=True) \
.save() \
.absolutepath
# Straighten the spinal cord
# straighten segmentation
printv('\nStraighten the spinal cord using centerline/segmentation...', verbose)
cache_sig = cache_signature(input_files=[fname_anat_rpi, fname_centerline_rpi],
input_params={"x": "spline"})
cachefile = os.path.join(curdir, "straightening.cache")
if cache_valid(cachefile, cache_sig) and os.path.isfile(os.path.join(curdir, 'warp_curve2straight.nii.gz')) and os.path.isfile(os.path.join(curdir, 'warp_straight2curve.nii.gz')) and os.path.isfile(os.path.join(curdir, 'straight_ref.nii.gz')):
# if they exist, copy them into current folder
printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
copy(os.path.join(curdir, 'warp_curve2straight.nii.gz'), 'warp_curve2straight.nii.gz')
copy(os.path.join(curdir, 'warp_straight2curve.nii.gz'), 'warp_straight2curve.nii.gz')
copy(os.path.join(curdir, 'straight_ref.nii.gz'), 'straight_ref.nii.gz')
# apply straightening
run_proc(['sct_apply_transfo', '-i', fname_anat_rpi, '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', 'anat_rpi_straight.nii', '-x', 'spline'], verbose)
else:
run_proc(['sct_straighten_spinalcord', '-i', fname_anat_rpi, '-o', 'anat_rpi_straight.nii', '-s', fname_centerline_rpi, '-x', 'spline', '-param', 'algo_fitting=' + param.algo_fitting], verbose)
cache_save(cachefile, cache_sig)
# move warping fields locally (to use caching next time)
copy('warp_curve2straight.nii.gz', os.path.join(curdir, 'warp_curve2straight.nii.gz'))
copy('warp_straight2curve.nii.gz', os.path.join(curdir, 'warp_straight2curve.nii.gz'))
# Smooth the straightened image along z
printv('\nSmooth the straightened image...')
sigma_smooth = ",".join([str(i) for i in sigma])
sct_maths.main(args=['-i', 'anat_rpi_straight.nii',
'-smooth', sigma_smooth,
'-o', 'anat_rpi_straight_smooth.nii',
'-v', '0'])
# Apply the reversed warping field to get back the curved spinal cord
printv('\nApply the reversed warping field to get back the curved spinal cord...')
run_proc(['sct_apply_transfo', '-i', 'anat_rpi_straight_smooth.nii', '-o', 'anat_rpi_straight_smooth_curved.nii', '-d', 'anat.nii', '-w', 'warp_straight2curve.nii.gz', '-x', 'spline'], verbose)
# replace zeroed voxels by original image (issue #937)
printv('\nReplace zeroed voxels by original image...', verbose)
nii_smooth = Image('anat_rpi_straight_smooth_curved.nii')
data_smooth = nii_smooth.data
data_input = Image('anat.nii').data
indzero = np.where(data_smooth == 0)
data_smooth[indzero] = data_input[indzero]
nii_smooth.data = data_smooth
nii_smooth.save('anat_rpi_straight_smooth_curved_nonzero.nii')
# come back
os.chdir(curdir)
# Generate output file
printv('\nGenerate output file...')
generate_output_file(os.path.join(path_tmp, "anat_rpi_straight_smooth_curved_nonzero.nii"),
file_anat + '_smooth' + ext_anat)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...')
rmtree(path_tmp)
# Display elapsed time
elapsed_time = time.time() - start_time
printv('\nFinished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's\n')
display_viewer_syntax([file_anat, file_anat + '_smooth'], verbose=verbose)
def compute_texture(self):
offset = int(self.param_glcm.distance)
printv('\nCompute texture metrics...', self.param.verbose, 'normal')
# open image and re-orient it to RPI if needed
im_tmp = Image(self.param.fname_im)
if self.orientation_im != self.orientation_extraction:
im_tmp.change_orientation(self.orientation_extraction)
dct_metric = {}
for m in self.metric_lst:
im_2save = zeros_like(im_tmp, dtype='float64')
dct_metric[m] = im_2save
# dct_metric[m] = Image(self.fname_metric_lst[m])
with sct_progress_bar() as pbar:
for im_z, seg_z, zz in zip(self.dct_im_seg['im'],
self.dct_im_seg['seg'],
range(len(self.dct_im_seg['im']))):
for xx in range(im_z.shape[0]):
for yy in range(im_z.shape[1]):
if not seg_z[xx, yy]:
continue
if xx < offset or yy < offset:
continue
if xx > (im_z.shape[0] - offset -
1) or yy > (im_z.shape[1] - offset - 1):
continue # to check if the whole glcm_window is in the axial_slice
if False in np.unique(
seg_z[xx - offset:xx + offset + 1,
yy - offset:yy + offset + 1]):
continue # to check if the whole glcm_window is in the mask of the axial_slice
glcm_window = im_z[xx - offset:xx + offset + 1,
yy - offset:yy + offset + 1]
glcm_window = glcm_window.astype(np.uint8)
dct_glcm = {}
for a in self.param_glcm.angle.split(
','
): # compute the GLCM for self.param_glcm.distance and for each self.param_glcm.angle
dct_glcm[a] = greycomatrix(
glcm_window, [self.param_glcm.distance],
[np.radians(int(a))],
symmetric=self.param_glcm.symmetric,
normed=self.param_glcm.normed)
for m in self.metric_lst: # compute the GLCM property (m.split('_')[0]) of the voxel xx,yy,zz
dct_metric[m].data[xx, yy, zz] = greycoprops(
dct_glcm[m.split('_')[2]],
m.split('_')[0])[0][0]
pbar.set_postfix(
pos="{}/{}".format(zz, len(self.dct_im_seg["im"])))
pbar.update(1)
for m in self.metric_lst:
fname_out = add_suffix(
"".join(extract_fname(self.param.fname_im)[1:]), '_' + m)
dct_metric[m].save(fname_out)
self.fname_metric_lst[m] = fname_out
def create_mask(param):
# parse argument for method
method_type = param.process[0]
# check method val
if not method_type == 'center':
method_val = param.process[1]
# check existence of input files
if method_type == 'centerline':
check_file_exist(method_val, param.verbose)
# Extract path/file/extension
path_data, file_data, ext_data = extract_fname(param.fname_data)
# Get output folder and file name
if param.fname_out == '':
param.fname_out = os.path.abspath(param.file_prefix + file_data +
ext_data)
path_tmp = tmp_create(basename="create_mask")
printv('\nOrientation:', param.verbose)
orientation_input = Image(param.fname_data).orientation
printv(' ' + orientation_input, param.verbose)
# copy input data to tmp folder and re-orient to RPI
Image(param.fname_data).change_orientation("RPI").save(
os.path.join(path_tmp, "data_RPI.nii"))
if method_type == 'centerline':
Image(method_val).change_orientation("RPI").save(
os.path.join(path_tmp, "centerline_RPI.nii"))
if method_type == 'point':
Image(method_val).change_orientation("RPI").save(
os.path.join(path_tmp, "point_RPI.nii"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Get dimensions of data
im_data = Image('data_RPI.nii')
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
printv('\nDimensions:', param.verbose)
printv(im_data.dim, param.verbose)
# in case user input 4d data
if nt != 1:
printv(
'WARNING in ' + os.path.basename(__file__) +
': Input image is 4d but output mask will be 3D from first time slice.',
param.verbose, 'warning')
# extract first volume to have 3d reference
nii = empty_like(Image('data_RPI.nii'))
data3d = nii.data[:, :, :, 0]
nii.data = data3d
nii.save('data_RPI.nii')
if method_type == 'coord':
# parse to get coordinate
coord = [x for x in map(int, method_val.split('x'))]
if method_type == 'point':
# extract coordinate of point
printv('\nExtract coordinate of point...', param.verbose)
coord = Image("point_RPI.nii").getNonZeroCoordinates()
if method_type == 'center':
# set coordinate at center of FOV
coord = np.round(float(nx) / 2), np.round(float(ny) / 2)
if method_type == 'centerline':
# get name of centerline from user argument
fname_centerline = 'centerline_RPI.nii'
else:
# generate volume with line along Z at coordinates 'coord'
printv('\nCreate line...', param.verbose)
fname_centerline = create_line(param, 'data_RPI.nii', coord, nz)
# create mask
printv('\nCreate mask...', param.verbose)
centerline = nibabel.load(fname_centerline) # open centerline
hdr = centerline.get_header() # get header
hdr.set_data_dtype('uint8') # set imagetype to uint8
spacing = hdr.structarr['pixdim']
data_centerline = centerline.get_data() # get centerline
# if data is 2D, reshape with empty third dimension
if len(data_centerline.shape) == 2:
data_centerline_shape = list(data_centerline.shape)
data_centerline_shape.append(1)
data_centerline = data_centerline.reshape(data_centerline_shape)
z_centerline_not_null = [
iz for iz in range(0, nz, 1) if data_centerline[:, :, iz].any()
]
# get center of mass of the centerline
cx = [0] * nz
cy = [0] * nz
for iz in range(0, nz, 1):
if iz in z_centerline_not_null:
cx[iz], cy[iz] = ndimage.measurements.center_of_mass(
np.array(data_centerline[:, :, iz]))
# create 2d masks
file_mask = 'data_mask'
for iz in range(nz):
if iz not in z_centerline_not_null:
# write an empty nifty volume
img = nibabel.Nifti1Image(data_centerline[:, :, iz], None, hdr)
nibabel.save(img, (file_mask + str(iz) + '.nii'))
else:
center = np.array([cx[iz], cy[iz]])
mask2d = create_mask2d(param,
center,
param.shape,
param.size,
im_data=im_data)
# Write NIFTI volumes
img = nibabel.Nifti1Image(mask2d, None, hdr)
nibabel.save(img, (file_mask + str(iz) + '.nii'))
fname_list = [file_mask + str(iz) + '.nii' for iz in range(nz)]
im_out = concat_data(fname_list, dim=2).save('mask_RPI.nii.gz')
im_out.change_orientation(orientation_input)
im_out.header = Image(param.fname_data).header
im_out.save(param.fname_out)
# come back
os.chdir(curdir)
# Remove temporary files
if param.remove_temp_files == 1:
printv('\nRemove temporary files...', param.verbose)
rmtree(path_tmp)
display_viewer_syntax([param.fname_data, param.fname_out],
colormaps=['gray', 'red'],
opacities=['', '0.5'])
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_loglevel(verbose=verbose)
# Input filename
fname_input_data = arguments.i
fname_data = os.path.abspath(fname_input_data)
# Method used
method = arguments.method
# Contrast type
contrast_type = arguments.c
if method == 'optic' and not contrast_type:
# Contrast must be
error = "ERROR: -c is a mandatory argument when using 'optic' method."
printv(error, type='error')
return
# Gap between slices
interslice_gap = arguments.gap
param_centerline = ParamCenterline(algo_fitting=arguments.centerline_algo,
smooth=arguments.centerline_smooth,
minmax=True)
# Output folder
if arguments.o is not None:
path_data, file_data, ext_data = extract_fname(arguments.o)
if not ext_data:
ext_data = '.nii.gz'
file_output = os.path.join(path_data, file_data + ext_data)
else:
path_data, file_data, ext_data = extract_fname(fname_data)
file_output = os.path.join(path_data, file_data + '_centerline.nii.gz')
if method == 'viewer':
# Manual labeling of cord centerline
im_labels = _call_viewer_centerline(Image(fname_data),
interslice_gap=interslice_gap)
elif method == 'fitseg':
im_labels = Image(fname_data)
elif method == 'optic':
# Automatic detection of cord centerline
im_labels = Image(fname_data)
param_centerline.algo_fitting = 'optic'
param_centerline.contrast = contrast_type
else:
printv(
"ERROR: The selected method is not available: {}. Please look at the help."
.format(method),
type='error')
return
# Extrapolate and regularize (or detect if optic) cord centerline
im_centerline, arr_centerline, _, _ = get_centerline(
im_labels, param=param_centerline, verbose=verbose)
# save centerline as nifti (discrete) and csv (continuous) files
im_centerline.save(file_output)
np.savetxt(file_output + '.csv', arr_centerline.transpose(), delimiter=",")
path_qc = arguments.qc
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
# Generate QC report
if path_qc is not None:
generate_qc(fname_input_data,
fname_seg=file_output,
args=sys.argv[1:],
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_get_centerline')
display_viewer_syntax([fname_input_data, file_output],
colormaps=['gray', 'red'],
opacities=['', '0.7'])
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_loglevel(verbose=verbose)
fname_in = os.path.abspath(arguments.i)
fname_seg = os.path.abspath(arguments.s)
contrast = arguments.c
path_template = os.path.abspath(arguments.t)
scale_dist = arguments.scale_dist
path_output = os.path.abspath(arguments.ofolder)
fname_disc = arguments.discfile
if fname_disc is not None:
fname_disc = os.path.abspath(fname_disc)
initz = arguments.initz
initcenter = arguments.initcenter
fname_initlabel = arguments.initlabel
if fname_initlabel is not None:
fname_initlabel = os.path.abspath(fname_initlabel)
remove_temp_files = arguments.r
clean_labels = arguments.clean_labels
path_tmp = tmp_create(basename="label_vertebrae")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder...', verbose)
Image(fname_in).save(os.path.join(path_tmp, "data.nii"))
Image(fname_seg).save(os.path.join(path_tmp, "segmentation.nii"))
# Go go temp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Straighten spinal cord
printv('\nStraighten spinal cord...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
cache_sig = cache_signature(input_files=[fname_in, fname_seg], )
fname_cache = "straightening.cache"
if (cache_valid(os.path.join(curdir, fname_cache), cache_sig)
and os.path.isfile(
os.path.join(curdir, "warp_curve2straight.nii.gz"))
and os.path.isfile(
os.path.join(curdir, "warp_straight2curve.nii.gz"))
and os.path.isfile(os.path.join(curdir, "straight_ref.nii.gz"))):
# if they exist, copy them into current folder
printv('Reusing existing warping field which seems to be valid',
verbose, 'warning')
copy(os.path.join(curdir, "warp_curve2straight.nii.gz"),
'warp_curve2straight.nii.gz')
copy(os.path.join(curdir, "warp_straight2curve.nii.gz"),
'warp_straight2curve.nii.gz')
copy(os.path.join(curdir, "straight_ref.nii.gz"),
'straight_ref.nii.gz')
# apply straightening
s, o = run_proc([
'sct_apply_transfo', '-i', 'data.nii', '-w',
'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o',
'data_straight.nii'
])
else:
sct_straighten_spinalcord.main(argv=[
'-i',
'data.nii',
'-s',
'segmentation.nii',
'-r',
str(remove_temp_files),
'-v',
'0',
])
cache_save(os.path.join(path_output, fname_cache), cache_sig)
# resample to 0.5mm isotropic to match template resolution
printv('\nResample to 0.5mm isotropic...', verbose)
s, o = run_proc([
'sct_resample', '-i', 'data_straight.nii', '-mm', '0.5x0.5x0.5', '-x',
'linear', '-o', 'data_straightr.nii'
],
verbose=verbose)
# Apply straightening to segmentation
# N.B. Output is RPI
printv('\nApply straightening to segmentation...', verbose)
sct_apply_transfo.main([
'-i', 'segmentation.nii', '-d', 'data_straightr.nii', '-w',
'warp_curve2straight.nii.gz', '-o', 'segmentation_straight.nii', '-x',
'linear', '-v', '0'
])
# Threshold segmentation at 0.5
img = Image('segmentation_straight.nii')
img.data = threshold(img.data, 0.5)
img.save()
# If disc label file is provided, label vertebrae using that file instead of automatically
if fname_disc:
# Apply straightening to disc-label
printv('\nApply straightening to disc labels...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
(fname_disc, 'data_straightr.nii', 'warp_curve2straight.nii.gz',
'labeldisc_straight.nii.gz', 'label'),
verbose=verbose)
label_vert('segmentation_straight.nii',
'labeldisc_straight.nii.gz',
verbose=1)
else:
printv('\nCreate label to identify disc...', verbose)
fname_labelz = os.path.join(path_tmp, 'labelz.nii.gz')
if initcenter is not None:
# find z centered in FOV
nii = Image('segmentation.nii').change_orientation("RPI")
nx, ny, nz, nt, px, py, pz, pt = nii.dim
z_center = round(nz / 2)
initz = [z_center, initcenter]
if initz is not None:
im_label = create_labels_along_segmentation(
Image('segmentation.nii'), [tuple(initz)])
im_label.save(fname_labelz)
elif fname_initlabel is not None:
Image(fname_initlabel).save(fname_labelz)
else:
# automatically finds C2-C3 disc
im_data = Image('data.nii')
im_seg = Image('segmentation.nii')
# because verbose is also used for keeping temp files
verbose_detect_c2c3 = 0 if remove_temp_files else 2
im_label_c2c3 = detect_c2c3(im_data,
im_seg,
contrast,
verbose=verbose_detect_c2c3)
ind_label = np.where(im_label_c2c3.data)
if np.size(ind_label) == 0:
printv(
'Automatic C2-C3 detection failed. Please provide manual label with sct_label_utils',
1, 'error')
sys.exit(1)
im_label_c2c3.data[ind_label] = 3
im_label_c2c3.save(fname_labelz)
# dilate label so it is not lost when applying warping
dilate(Image(fname_labelz), 3, 'ball').save(fname_labelz)
# Apply straightening to z-label
printv('\nAnd apply straightening to label...', verbose)
sct_apply_transfo.main([
'-i', 'labelz.nii.gz', '-d', 'data_straightr.nii', '-w',
'warp_curve2straight.nii.gz', '-o', 'labelz_straight.nii.gz', '-x',
'nn', '-v', '0'
])
# get z value and disk value to initialize labeling
printv('\nGet z and disc values from straight label...', verbose)
init_disc = get_z_and_disc_values_from_label('labelz_straight.nii.gz')
printv('.. ' + str(init_disc), verbose)
# apply laplacian filtering
if arguments.laplacian:
printv('\nApply Laplacian filter...', verbose)
img = Image("data_straightr.nii")
# apply std dev to each axis of the image
sigmas = [1 for i in range(len(img.data.shape))]
# adjust sigma based on voxel size
sigmas = [sigmas[i] / img.dim[i + 4] for i in range(3)]
# smooth data
img.data = laplacian(img.data, sigmas)
img.save()
# detect vertebral levels on straight spinal cord
init_disc[1] = init_disc[1] - 1
vertebral_detection('data_straightr.nii',
'segmentation_straight.nii',
contrast,
arguments.param,
init_disc=init_disc,
verbose=verbose,
path_template=path_template,
path_output=path_output,
scale_dist=scale_dist)
# un-straighten labeled spinal cord
printv('\nUn-straighten labeling...', verbose)
sct_apply_transfo.main([
'-i', 'segmentation_straight_labeled.nii', '-d', 'segmentation.nii',
'-w', 'warp_straight2curve.nii.gz', '-o', 'segmentation_labeled.nii',
'-x', 'nn', '-v', '0'
])
if clean_labels >= 1:
printv('\nCleaning labeled segmentation:', verbose)
im_labeled_seg = Image('segmentation_labeled.nii')
im_seg = Image('segmentation.nii')
if clean_labels >= 2:
printv(' filling in missing label voxels ...', verbose)
expand_labels(im_labeled_seg)
printv(' removing labeled voxels outside segmentation...', verbose)
crop_labels(im_labeled_seg, im_seg)
printv('Done cleaning.', verbose)
im_labeled_seg.save()
# label discs
printv('\nLabel discs...', verbose)
printv('\nUn-straighten labeled discs...', verbose)
run_proc(
'sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
('segmentation_straight_labeled_disc.nii', 'segmentation.nii',
'warp_straight2curve.nii.gz', 'segmentation_labeled_disc.nii',
'label'),
verbose=verbose,
is_sct_binary=True,
)
# come back
os.chdir(curdir)
# Generate output files
path_seg, file_seg, ext_seg = extract_fname(fname_seg)
fname_seg_labeled = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
printv('\nGenerate output files...', verbose)
generate_output_file(os.path.join(path_tmp, "segmentation_labeled.nii"),
fname_seg_labeled)
generate_output_file(
os.path.join(path_tmp, "segmentation_labeled_disc.nii"),
os.path.join(path_output, file_seg + '_labeled_discs' + ext_seg))
# copy straightening files in case subsequent SCT functions need them
generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"),
os.path.join(path_output,
"warp_curve2straight.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"),
os.path.join(path_output,
"warp_straight2curve.nii.gz"),
verbose=verbose)
generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"),
os.path.join(path_output, "straight_ref.nii.gz"),
verbose=verbose)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp)
# Generate QC report
if arguments.qc is not None:
path_qc = os.path.abspath(arguments.qc)
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
labeled_seg_file = os.path.join(path_output,
file_seg + '_labeled' + ext_seg)
generate_qc(fname_in,
fname_seg=labeled_seg_file,
args=argv,
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_label_vertebrae')
display_viewer_syntax([fname_in, fname_seg_labeled],
colormaps=['', 'subcortical'],
opacities=['1', '0.5'])
def apply(self):
# Initialization
fname_src = self.input_filename # source image (moving)
list_warp = self.list_warp # list of warping fields
fname_out = self.output_filename # output
fname_dest = self.fname_dest # destination image (fix)
verbose = self.verbose
remove_temp_files = self.remove_temp_files
crop_reference = self.crop # if = 1, put 0 everywhere around warping field, if = 2, real crop
islabel = False
if self.interp == 'label':
islabel = True
self.interp = 'nn'
interp = get_interpolation('isct_antsApplyTransforms', self.interp)
# Parse list of warping fields
printv('\nParse list of warping fields...', verbose)
use_inverse = []
fname_warp_list_invert = []
# list_warp = list_warp.replace(' ', '') # remove spaces
# list_warp = list_warp.split(",") # parse with comma
for idx_warp, path_warp in enumerate(self.list_warp):
# Check if this transformation should be inverted
if path_warp in self.list_warpinv:
use_inverse.append('-i')
# list_warp[idx_warp] = path_warp[1:] # remove '-'
fname_warp_list_invert += [[
use_inverse[idx_warp], list_warp[idx_warp]
]]
else:
use_inverse.append('')
fname_warp_list_invert += [[path_warp]]
path_warp = list_warp[idx_warp]
if path_warp.endswith((".nii", ".nii.gz")) \
and Image(list_warp[idx_warp]).header.get_intent()[0] != 'vector':
raise ValueError(
"Displacement field in {} is invalid: should be encoded"
" in a 5D file with vector intent code"
" (see https://nifti.nimh.nih.gov/pub/dist/src/niftilib/nifti1.h"
.format(path_warp))
# need to check if last warping field is an affine transfo
isLastAffine = False
path_fname, file_fname, ext_fname = extract_fname(
fname_warp_list_invert[-1][-1])
if ext_fname in ['.txt', '.mat']:
isLastAffine = True
# check if destination file is 3d
# check_dim(fname_dest, dim_lst=[3]) # PR 2598: we decided to skip this line.
# N.B. Here we take the inverse of the warp list, because sct_WarpImageMultiTransform concatenates in the reverse order
fname_warp_list_invert.reverse()
fname_warp_list_invert = functools.reduce(lambda x, y: x + y,
fname_warp_list_invert)
# Extract path, file and extension
path_src, file_src, ext_src = extract_fname(fname_src)
path_dest, file_dest, ext_dest = extract_fname(fname_dest)
# Get output folder and file name
if fname_out == '':
path_out = '' # output in user's current directory
file_out = file_src + '_reg'
ext_out = ext_src
fname_out = os.path.join(path_out, file_out + ext_out)
# Get dimensions of data
printv('\nGet dimensions of data...', verbose)
img_src = Image(fname_src)
nx, ny, nz, nt, px, py, pz, pt = img_src.dim
# nx, ny, nz, nt, px, py, pz, pt = get_dimension(fname_src)
printv(
' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' +
str(nt), verbose)
# if 3d
if nt == 1:
# Apply transformation
printv('\nApply transformation...', verbose)
if nz in [0, 1]:
dim = '2'
else:
dim = '3'
# if labels, dilate before resampling
if islabel:
printv("\nDilate labels before warping...")
path_tmp = tmp_create(basename="apply_transfo")
fname_dilated_labels = os.path.join(path_tmp,
"dilated_data.nii")
# dilate points
dilate(Image(fname_src), 4, 'ball').save(fname_dilated_labels)
fname_src = fname_dilated_labels
printv(
"\nApply transformation and resample to destination space...",
verbose)
run_proc([
'isct_antsApplyTransforms', '-d', dim, '-i', fname_src, '-o',
fname_out, '-t'
] + fname_warp_list_invert + ['-r', fname_dest] + interp,
is_sct_binary=True)
# if 4d, loop across the T dimension
else:
if islabel:
raise NotImplementedError
dim = '4'
path_tmp = tmp_create(basename="apply_transfo")
# convert to nifti into temp folder
printv('\nCopying input data to tmp folder and convert to nii...',
verbose)
img_src.save(os.path.join(path_tmp, "data.nii"))
copy(fname_dest, os.path.join(path_tmp, file_dest + ext_dest))
fname_warp_list_tmp = []
for fname_warp in list_warp:
path_warp, file_warp, ext_warp = extract_fname(fname_warp)
copy(fname_warp, os.path.join(path_tmp, file_warp + ext_warp))
fname_warp_list_tmp.append(file_warp + ext_warp)
fname_warp_list_invert_tmp = fname_warp_list_tmp[::-1]
curdir = os.getcwd()
os.chdir(path_tmp)
# split along T dimension
printv('\nSplit along T dimension...', verbose)
im_dat = Image('data.nii')
im_header = im_dat.hdr
data_split_list = sct_image.split_data(im_dat, 3)
for im in data_split_list:
im.save()
# apply transfo
printv('\nApply transformation to each 3D volume...', verbose)
for it in range(nt):
file_data_split = 'data_T' + str(it).zfill(4) + '.nii'
file_data_split_reg = 'data_reg_T' + str(it).zfill(4) + '.nii'
status, output = run_proc([
'isct_antsApplyTransforms',
'-d',
'3',
'-i',
file_data_split,
'-o',
file_data_split_reg,
'-t',
] + fname_warp_list_invert_tmp + [
'-r',
file_dest + ext_dest,
] + interp,
verbose,
is_sct_binary=True)
# Merge files back
printv('\nMerge file back...', verbose)
import glob
path_out, name_out, ext_out = extract_fname(fname_out)
# im_list = [Image(file_name) for file_name in glob.glob('data_reg_T*.nii')]
# concat_data use to take a list of image in input, now takes a list of file names to open the files one by one (see issue #715)
fname_list = glob.glob('data_reg_T*.nii')
fname_list.sort()
im_list = [Image(fname) for fname in fname_list]
im_out = sct_image.concat_data(im_list, 3, im_header['pixdim'])
im_out.save(name_out + ext_out)
os.chdir(curdir)
generate_output_file(os.path.join(path_tmp, name_out + ext_out),
fname_out)
# Delete temporary folder if specified
if remove_temp_files:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp, verbose=verbose)
# Copy affine matrix from destination space to make sure qform/sform are the same
printv(
"Copy affine matrix from destination space to make sure qform/sform are the same.",
verbose)
im_src_reg = Image(fname_out)
im_src_reg.copy_qform_from_ref(Image(fname_dest))
im_src_reg.save(
verbose=0
) # set verbose=0 to avoid warning message about rewriting file
if islabel:
printv(
"\nTake the center of mass of each registered dilated labels..."
)
labeled_img = cubic_to_point(im_src_reg)
labeled_img.save(path=fname_out)
if remove_temp_files:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp, verbose=verbose)
# Crop the resulting image using dimensions from the warping field
warping_field = fname_warp_list_invert[-1]
# If the last transformation is not an affine transfo, we need to compute the matrix space of the concatenated
# warping field
if not isLastAffine and crop_reference in [1, 2]:
printv('Last transformation is not affine.')
if crop_reference in [1, 2]:
# Extract only the first ndim of the warping field
img_warp = Image(warping_field)
if dim == '2':
img_warp_ndim = Image(img_src.data[:, :], hdr=img_warp.hdr)
elif dim in ['3', '4']:
img_warp_ndim = Image(img_src.data[:, :, :],
hdr=img_warp.hdr)
# Set zero to everything outside the warping field
cropper = ImageCropper(Image(fname_out))
cropper.get_bbox_from_ref(img_warp_ndim)
if crop_reference == 1:
printv(
'Cropping strategy is: keep same matrix size, put 0 everywhere around warping field'
)
img_out = cropper.crop(background=0)
elif crop_reference == 2:
printv(
'Cropping strategy is: crop around warping field (the size of warping field will '
'change)')
img_out = cropper.crop()
img_out.save(fname_out)
display_viewer_syntax([fname_dest, fname_out], verbose=verbose)
def straighten(self):
"""
Straighten spinal cord. Steps: (everything is done in physical space)
1. open input image and centreline image
2. extract bspline fitting of the centreline, and its derivatives
3. compute length of centerline
4. compute and generate straight space
5. compute transformations
for each voxel of one space: (done using matrices --> improves speed by a factor x300)
a. determine which plane of spinal cord centreline it is included
b. compute the position of the voxel in the plane (X and Y distance from centreline, along the plane)
c. find the correspondant centreline point in the other space
d. find the correspondance of the voxel in the corresponding plane
6. generate warping fields for each transformations
7. write warping fields and apply them
step 5.b: how to find the corresponding plane?
The centerline plane corresponding to a voxel correspond to the nearest point of the centerline.
However, we need to compute the distance between the voxel position and the plane to be sure it is part of the plane and not too distant.
If it is more far than a threshold, warping value should be 0.
step 5.d: how to make the correspondance between centerline point in both images?
Both centerline have the same lenght. Therefore, we can map centerline point via their position along the curve.
If we use the same number of points uniformely along the spinal cord (1000 for example), the correspondance is straight-forward.
:return:
"""
# Initialization
fname_anat = self.input_filename
fname_centerline = self.centerline_filename
fname_output = self.output_filename
remove_temp_files = self.remove_temp_files
verbose = self.verbose
interpolation_warp = self.interpolation_warp # TODO: remove this
# start timer
start_time = time.time()
# Extract path/file/extension
path_anat, file_anat, ext_anat = extract_fname(fname_anat)
path_tmp = tmp_create(basename="straighten_spinalcord")
# Copying input data to tmp folder
logger.info('Copy files to tmp folder...')
Image(fname_anat).save(os.path.join(path_tmp, "data.nii"))
Image(fname_centerline).save(os.path.join(path_tmp, "centerline.nii.gz"))
if self.use_straight_reference:
Image(self.centerline_reference_filename).save(os.path.join(path_tmp, "centerline_ref.nii.gz"))
if self.discs_input_filename != '':
Image(self.discs_input_filename).save(os.path.join(path_tmp, "labels_input.nii.gz"))
if self.discs_ref_filename != '':
Image(self.discs_ref_filename).save(os.path.join(path_tmp, "labels_ref.nii.gz"))
# go to tmp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Change orientation of the input centerline into RPI
image_centerline = Image("centerline.nii.gz").change_orientation("RPI").save("centerline_rpi.nii.gz",
mutable=True)
# Get dimension
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
if self.speed_factor != 1.0:
intermediate_resampling = True
px_r, py_r, pz_r = px * self.speed_factor, py * self.speed_factor, pz * self.speed_factor
else:
intermediate_resampling = False
if intermediate_resampling:
mv('centerline_rpi.nii.gz', 'centerline_rpi_native.nii.gz')
pz_native = pz
# TODO: remove system call
run_proc(['sct_resample', '-i', 'centerline_rpi_native.nii.gz', '-mm',
str(px_r) + 'x' + str(py_r) + 'x' + str(pz_r), '-o', 'centerline_rpi.nii.gz'])
image_centerline = Image('centerline_rpi.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
if np.min(image_centerline.data) < 0 or np.max(image_centerline.data) > 1:
image_centerline.data[image_centerline.data < 0] = 0
image_centerline.data[image_centerline.data > 1] = 1
image_centerline.save()
# 2. extract bspline fitting of the centerline, and its derivatives
img_ctl = Image('centerline_rpi.nii.gz')
centerline = _get_centerline(img_ctl, self.param_centerline, verbose)
number_of_points = centerline.number_of_points
# ==========================================================================================
logger.info('Create the straight space and the safe zone')
# 3. compute length of centerline
# compute the length of the spinal cord based on fitted centerline and size of centerline in z direction
# Computation of the safe zone.
# The safe zone is defined as the length of the spinal cord for which an axial segmentation will be complete
# The safe length (to remove) is computed using the safe radius (given as parameter) and the angle of the
# last centerline point with the inferior-superior direction. Formula: Ls = Rs * sin(angle)
# Calculate Ls for both edges and remove appropriate number of centerline points
radius_safe = 0.0 # mm
# inferior edge
u = centerline.derivatives[0]
v = np.array([0, 0, -1])
angle_inferior = np.arctan2(np.linalg.norm(np.cross(u, v)), np.dot(u, v))
length_safe_inferior = radius_safe * np.sin(angle_inferior)
# superior edge
u = centerline.derivatives[-1]
v = np.array([0, 0, 1])
angle_superior = np.arctan2(np.linalg.norm(np.cross(u, v)), np.dot(u, v))
length_safe_superior = radius_safe * np.sin(angle_superior)
# remove points
inferior_bound = bisect.bisect(centerline.progressive_length, length_safe_inferior) - 1
superior_bound = centerline.number_of_points - bisect.bisect(centerline.progressive_length_inverse,
length_safe_superior)
z_centerline = centerline.points[:, 2]
length_centerline = centerline.length
size_z_centerline = z_centerline[-1] - z_centerline[0]
# compute the size factor between initial centerline and straight bended centerline
factor_curved_straight = length_centerline / size_z_centerline
middle_slice = (z_centerline[0] + z_centerline[-1]) / 2.0
bound_curved = [z_centerline[inferior_bound], z_centerline[superior_bound]]
bound_straight = [(z_centerline[inferior_bound] - middle_slice) * factor_curved_straight + middle_slice,
(z_centerline[superior_bound] - middle_slice) * factor_curved_straight + middle_slice]
logger.info('Length of spinal cord: {}'.format(length_centerline))
logger.info('Size of spinal cord in z direction: {}'.format(size_z_centerline))
logger.info('Ratio length/size: {}'.format(factor_curved_straight))
logger.info('Safe zone boundaries (curved space): {}'.format(bound_curved))
logger.info('Safe zone boundaries (straight space): {}'.format(bound_straight))
# 4. compute and generate straight space
# points along curved centerline are already regularly spaced.
# calculate position of points along straight centerline
# Create straight NIFTI volumes.
# ==========================================================================================
# TODO: maybe this if case is not needed?
if self.use_straight_reference:
image_centerline_pad = Image('centerline_rpi.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline_pad.dim
fname_ref = 'centerline_ref_rpi.nii.gz'
image_centerline_straight = Image('centerline_ref.nii.gz') \
.change_orientation("RPI") \
.save(fname_ref, mutable=True)
centerline_straight = _get_centerline(image_centerline_straight, self.param_centerline, verbose)
nx_s, ny_s, nz_s, nt_s, px_s, py_s, pz_s, pt_s = image_centerline_straight.dim
# Prepare warping fields headers
hdr_warp = image_centerline_pad.hdr.copy()
hdr_warp.set_data_dtype('float32')
hdr_warp_s = image_centerline_straight.hdr.copy()
hdr_warp_s.set_data_dtype('float32')
if self.discs_input_filename != "" and self.discs_ref_filename != "":
discs_input_image = Image('labels_input.nii.gz')
coord = discs_input_image.getNonZeroCoordinates(sorting='z', reverse_coord=True)
coord_physical = []
for c in coord:
c_p = discs_input_image.transfo_pix2phys([[c.x, c.y, c.z]]).tolist()[0]
c_p.append(c.value)
coord_physical.append(c_p)
centerline.compute_vertebral_distribution(coord_physical)
centerline.save_centerline(image=discs_input_image, fname_output='discs_input_image.nii.gz')
discs_ref_image = Image('labels_ref.nii.gz')
coord = discs_ref_image.getNonZeroCoordinates(sorting='z', reverse_coord=True)
coord_physical = []
for c in coord:
c_p = discs_ref_image.transfo_pix2phys([[c.x, c.y, c.z]]).tolist()[0]
c_p.append(c.value)
coord_physical.append(c_p)
centerline_straight.compute_vertebral_distribution(coord_physical)
centerline_straight.save_centerline(image=discs_ref_image, fname_output='discs_ref_image.nii.gz')
else:
logger.info('Pad input volume to account for spinal cord length...')
start_point, end_point = bound_straight[0], bound_straight[1]
offset_z = 0
# if the destination image is resampled, we still create the straight reference space with the native
# resolution.
# TODO: Maybe this if case is not needed?
if intermediate_resampling:
padding_z = int(np.ceil(1.5 * ((length_centerline - size_z_centerline) / 2.0) / pz_native))
run_proc(
['sct_image', '-i', 'centerline_rpi_native.nii.gz', '-o', 'tmp.centerline_pad_native.nii.gz',
'-pad', '0,0,' + str(padding_z)])
image_centerline_pad = Image('centerline_rpi_native.nii.gz')
nx, ny, nz, nt, px, py, pz, pt = image_centerline_pad.dim
start_point_coord_native = image_centerline_pad.transfo_phys2pix([[0, 0, start_point]])[0]
end_point_coord_native = image_centerline_pad.transfo_phys2pix([[0, 0, end_point]])[0]
straight_size_x = int(self.xy_size / px)
straight_size_y = int(self.xy_size / py)
warp_space_x = [int(np.round(nx / 2)) - straight_size_x, int(np.round(nx / 2)) + straight_size_x]
warp_space_y = [int(np.round(ny / 2)) - straight_size_y, int(np.round(ny / 2)) + straight_size_y]
if warp_space_x[0] < 0:
warp_space_x[1] += warp_space_x[0] - 2
warp_space_x[0] = 0
if warp_space_y[0] < 0:
warp_space_y[1] += warp_space_y[0] - 2
warp_space_y[0] = 0
spec = dict((
(0, warp_space_x),
(1, warp_space_y),
(2, (0, end_point_coord_native[2] - start_point_coord_native[2])),
))
spatial_crop(Image("tmp.centerline_pad_native.nii.gz"), spec).save(
"tmp.centerline_pad_crop_native.nii.gz")
fname_ref = 'tmp.centerline_pad_crop_native.nii.gz'
offset_z = 4
else:
fname_ref = 'tmp.centerline_pad_crop.nii.gz'
nx, ny, nz, nt, px, py, pz, pt = image_centerline.dim
padding_z = int(np.ceil(1.5 * ((length_centerline - size_z_centerline) / 2.0) / pz)) + offset_z
image_centerline_pad = pad_image(image_centerline, pad_z_i=padding_z, pad_z_f=padding_z)
nx, ny, nz = image_centerline_pad.data.shape
hdr_warp = image_centerline_pad.hdr.copy()
hdr_warp.set_data_dtype('float32')
start_point_coord = image_centerline_pad.transfo_phys2pix([[0, 0, start_point]])[0]
end_point_coord = image_centerline_pad.transfo_phys2pix([[0, 0, end_point]])[0]
straight_size_x = int(self.xy_size / px)
straight_size_y = int(self.xy_size / py)
warp_space_x = [int(np.round(nx / 2)) - straight_size_x, int(np.round(nx / 2)) + straight_size_x]
warp_space_y = [int(np.round(ny / 2)) - straight_size_y, int(np.round(ny / 2)) + straight_size_y]
if warp_space_x[0] < 0:
warp_space_x[1] += warp_space_x[0] - 2
warp_space_x[0] = 0
if warp_space_x[1] >= nx:
warp_space_x[1] = nx - 1
if warp_space_y[0] < 0:
warp_space_y[1] += warp_space_y[0] - 2
warp_space_y[0] = 0
if warp_space_y[1] >= ny:
warp_space_y[1] = ny - 1
spec = dict((
(0, warp_space_x),
(1, warp_space_y),
(2, (0, end_point_coord[2] - start_point_coord[2] + offset_z)),
))
image_centerline_straight = spatial_crop(image_centerline_pad, spec)
nx_s, ny_s, nz_s, nt_s, px_s, py_s, pz_s, pt_s = image_centerline_straight.dim
hdr_warp_s = image_centerline_straight.hdr.copy()
hdr_warp_s.set_data_dtype('float32')
if self.template_orientation == 1:
raise NotImplementedError()
start_point_coord = image_centerline_pad.transfo_phys2pix([[0, 0, start_point]])[0]
end_point_coord = image_centerline_pad.transfo_phys2pix([[0, 0, end_point]])[0]
number_of_voxel = nx * ny * nz
logger.debug('Number of voxels: {}'.format(number_of_voxel))
time_centerlines = time.time()
coord_straight = np.empty((number_of_points, 3))
coord_straight[..., 0] = int(np.round(nx_s / 2))
coord_straight[..., 1] = int(np.round(ny_s / 2))
coord_straight[..., 2] = np.linspace(0, end_point_coord[2] - start_point_coord[2], number_of_points)
coord_phys_straight = image_centerline_straight.transfo_pix2phys(coord_straight)
derivs_straight = np.empty((number_of_points, 3))
derivs_straight[..., 0] = derivs_straight[..., 1] = 0
derivs_straight[..., 2] = 1
dx_straight, dy_straight, dz_straight = derivs_straight.T
centerline_straight = Centerline(coord_phys_straight[:, 0], coord_phys_straight[:, 1],
coord_phys_straight[:, 2],
dx_straight, dy_straight, dz_straight)
time_centerlines = time.time() - time_centerlines
logger.info('Time to generate centerline: {} ms'.format(np.round(time_centerlines * 1000.0)))
if verbose == 2:
# TODO: use OO
import matplotlib.pyplot as plt
from datetime import datetime
curved_points = centerline.progressive_length
straight_points = centerline_straight.progressive_length
range_points = np.linspace(0, 1, number_of_points)
dist_curved = np.zeros(number_of_points)
dist_straight = np.zeros(number_of_points)
for i in range(1, number_of_points):
dist_curved[i] = dist_curved[i - 1] + curved_points[i - 1] / centerline.length
dist_straight[i] = dist_straight[i - 1] + straight_points[i - 1] / centerline_straight.length
plt.plot(range_points, dist_curved)
plt.plot(range_points, dist_straight)
plt.grid(True)
plt.savefig('fig_straighten_' + datetime.now().strftime("%y%m%d%H%M%S%f") + '.png')
plt.close()
# alignment_mode = 'length'
alignment_mode = 'levels'
lookup_curved2straight = list(range(centerline.number_of_points))
if self.discs_input_filename != "":
# create look-up table curved to straight
for index in range(centerline.number_of_points):
disc_label = centerline.l_points[index]
if alignment_mode == 'length':
relative_position = centerline.dist_points[index]
else:
relative_position = centerline.dist_points_rel[index]
idx_closest = centerline_straight.get_closest_to_absolute_position(disc_label, relative_position,
backup_index=index,
backup_centerline=centerline_straight,
mode=alignment_mode)
if idx_closest is not None:
lookup_curved2straight[index] = idx_closest
else:
lookup_curved2straight[index] = 0
for p in range(0, len(lookup_curved2straight) // 2):
if lookup_curved2straight[p] == lookup_curved2straight[p + 1]:
lookup_curved2straight[p] = 0
else:
break
for p in range(len(lookup_curved2straight) - 1, len(lookup_curved2straight) // 2, -1):
if lookup_curved2straight[p] == lookup_curved2straight[p - 1]:
lookup_curved2straight[p] = 0
else:
break
lookup_curved2straight = np.array(lookup_curved2straight)
lookup_straight2curved = list(range(centerline_straight.number_of_points))
if self.discs_input_filename != "":
for index in range(centerline_straight.number_of_points):
disc_label = centerline_straight.l_points[index]
if alignment_mode == 'length':
relative_position = centerline_straight.dist_points[index]
else:
relative_position = centerline_straight.dist_points_rel[index]
idx_closest = centerline.get_closest_to_absolute_position(disc_label, relative_position,
backup_index=index,
backup_centerline=centerline_straight,
mode=alignment_mode)
if idx_closest is not None:
lookup_straight2curved[index] = idx_closest
for p in range(0, len(lookup_straight2curved) // 2):
if lookup_straight2curved[p] == lookup_straight2curved[p + 1]:
lookup_straight2curved[p] = 0
else:
break
for p in range(len(lookup_straight2curved) - 1, len(lookup_straight2curved) // 2, -1):
if lookup_straight2curved[p] == lookup_straight2curved[p - 1]:
lookup_straight2curved[p] = 0
else:
break
lookup_straight2curved = np.array(lookup_straight2curved)
# Create volumes containing curved and straight warping fields
data_warp_curved2straight = np.zeros((nx_s, ny_s, nz_s, 1, 3))
data_warp_straight2curved = np.zeros((nx, ny, nz, 1, 3))
# 5. compute transformations
# Curved and straight images and the same dimensions, so we compute both warping fields at the same time.
# b. determine which plane of spinal cord centreline it is included
if self.curved2straight:
for u in sct_progress_bar(range(nz_s)):
x_s, y_s, z_s = np.mgrid[0:nx_s, 0:ny_s, u:u + 1]
indexes_straight = np.array(list(zip(x_s.ravel(), y_s.ravel(), z_s.ravel())))
physical_coordinates_straight = image_centerline_straight.transfo_pix2phys(indexes_straight)
nearest_indexes_straight = centerline_straight.find_nearest_indexes(physical_coordinates_straight)
distances_straight = centerline_straight.get_distances_from_planes(physical_coordinates_straight,
nearest_indexes_straight)
lookup = lookup_straight2curved[nearest_indexes_straight]
indexes_out_distance_straight = np.logical_or(
np.logical_or(distances_straight > self.threshold_distance,
distances_straight < -self.threshold_distance), lookup == 0)
projected_points_straight = centerline_straight.get_projected_coordinates_on_planes(
physical_coordinates_straight, nearest_indexes_straight)
coord_in_planes_straight = centerline_straight.get_in_plans_coordinates(projected_points_straight,
nearest_indexes_straight)
coord_straight2curved = centerline.get_inverse_plans_coordinates(coord_in_planes_straight, lookup)
displacements_straight = coord_straight2curved - physical_coordinates_straight
# Invert Z coordinate as ITK & ANTs physical coordinate system is LPS- (RAI+)
# while ours is LPI-
# Refs: https://sourceforge.net/p/advants/discussion/840261/thread/2a1e9307/#fb5a
# https://www.slicer.org/wiki/Coordinate_systems
displacements_straight[:, 2] = -displacements_straight[:, 2]
displacements_straight[indexes_out_distance_straight] = [100000.0, 100000.0, 100000.0]
data_warp_curved2straight[indexes_straight[:, 0], indexes_straight[:, 1], indexes_straight[:, 2], 0, :]\
= -displacements_straight
if self.straight2curved:
for u in sct_progress_bar(range(nz)):
x, y, z = np.mgrid[0:nx, 0:ny, u:u + 1]
indexes = np.array(list(zip(x.ravel(), y.ravel(), z.ravel())))
physical_coordinates = image_centerline_pad.transfo_pix2phys(indexes)
nearest_indexes_curved = centerline.find_nearest_indexes(physical_coordinates)
distances_curved = centerline.get_distances_from_planes(physical_coordinates,
nearest_indexes_curved)
lookup = lookup_curved2straight[nearest_indexes_curved]
indexes_out_distance_curved = np.logical_or(
np.logical_or(distances_curved > self.threshold_distance,
distances_curved < -self.threshold_distance), lookup == 0)
projected_points_curved = centerline.get_projected_coordinates_on_planes(physical_coordinates,
nearest_indexes_curved)
coord_in_planes_curved = centerline.get_in_plans_coordinates(projected_points_curved,
nearest_indexes_curved)
coord_curved2straight = centerline_straight.points[lookup]
coord_curved2straight[:, 0:2] += coord_in_planes_curved[:, 0:2]
coord_curved2straight[:, 2] += distances_curved
displacements_curved = coord_curved2straight - physical_coordinates
displacements_curved[:, 2] = -displacements_curved[:, 2]
displacements_curved[indexes_out_distance_curved] = [100000.0, 100000.0, 100000.0]
data_warp_straight2curved[indexes[:, 0], indexes[:, 1], indexes[:, 2], 0, :] = -displacements_curved
# Creation of the safe zone based on pre-calculated safe boundaries
coord_bound_curved_inf, coord_bound_curved_sup = image_centerline_pad.transfo_phys2pix(
[[0, 0, bound_curved[0]]]), image_centerline_pad.transfo_phys2pix([[0, 0, bound_curved[1]]])
coord_bound_straight_inf, coord_bound_straight_sup = image_centerline_straight.transfo_phys2pix(
[[0, 0, bound_straight[0]]]), image_centerline_straight.transfo_phys2pix([[0, 0, bound_straight[1]]])
if radius_safe > 0:
data_warp_curved2straight[:, :, 0:coord_bound_straight_inf[0][2], 0, :] = 100000.0
data_warp_curved2straight[:, :, coord_bound_straight_sup[0][2]:, 0, :] = 100000.0
data_warp_straight2curved[:, :, 0:coord_bound_curved_inf[0][2], 0, :] = 100000.0
data_warp_straight2curved[:, :, coord_bound_curved_sup[0][2]:, 0, :] = 100000.0
# Generate warp files as a warping fields
hdr_warp_s.set_intent('vector', (), '')
hdr_warp_s.set_data_dtype('float32')
hdr_warp.set_intent('vector', (), '')
hdr_warp.set_data_dtype('float32')
if self.curved2straight:
img = Nifti1Image(data_warp_curved2straight, None, hdr_warp_s)
save(img, 'tmp.curve2straight.nii.gz')
logger.info('Warping field generated: tmp.curve2straight.nii.gz')
if self.straight2curved:
img = Nifti1Image(data_warp_straight2curved, None, hdr_warp)
save(img, 'tmp.straight2curve.nii.gz')
logger.info('Warping field generated: tmp.straight2curve.nii.gz')
image_centerline_straight.save(fname_ref)
if self.curved2straight:
logger.info('Apply transformation to input image...')
run_proc(['isct_antsApplyTransforms',
'-d', '3',
'-r', fname_ref,
'-i', 'data.nii',
'-o', 'tmp.anat_rigid_warp.nii.gz',
'-t', 'tmp.curve2straight.nii.gz',
'-n', 'BSpline[3]'],
is_sct_binary=True,
verbose=verbose)
if self.accuracy_results:
time_accuracy_results = time.time()
# compute the error between the straightened centerline/segmentation and the central vertical line.
# Ideally, the error should be zero.
# Apply deformation to input image
logger.info('Apply transformation to centerline image...')
run_proc(['isct_antsApplyTransforms',
'-d', '3',
'-r', fname_ref,
'-i', 'centerline.nii.gz',
'-o', 'tmp.centerline_straight.nii.gz',
'-t', 'tmp.curve2straight.nii.gz',
'-n', 'NearestNeighbor'],
is_sct_binary=True,
verbose=verbose)
file_centerline_straight = Image('tmp.centerline_straight.nii.gz', verbose=verbose)
nx, ny, nz, nt, px, py, pz, pt = file_centerline_straight.dim
coordinates_centerline = file_centerline_straight.getNonZeroCoordinates(sorting='z')
mean_coord = []
for z in range(coordinates_centerline[0].z, coordinates_centerline[-1].z):
temp_mean = [coord.value for coord in coordinates_centerline if coord.z == z]
if temp_mean:
mean_value = np.mean(temp_mean)
mean_coord.append(
np.mean([[coord.x * coord.value / mean_value, coord.y * coord.value / mean_value]
for coord in coordinates_centerline if coord.z == z], axis=0))
# compute error between the straightened centerline and the straight line.
x0 = file_centerline_straight.data.shape[0] / 2.0
y0 = file_centerline_straight.data.shape[1] / 2.0
count_mean = 0
if number_of_points >= 10:
mean_c = mean_coord[2:-2] # we don't include the four extrema because there are usually messy.
else:
mean_c = mean_coord
for coord_z in mean_c:
if not np.isnan(np.sum(coord_z)):
dist = ((x0 - coord_z[0]) * px) ** 2 + ((y0 - coord_z[1]) * py) ** 2
self.mse_straightening += dist
dist = np.sqrt(dist)
if dist > self.max_distance_straightening:
self.max_distance_straightening = dist
count_mean += 1
self.mse_straightening = np.sqrt(self.mse_straightening / float(count_mean))
self.elapsed_time_accuracy = time.time() - time_accuracy_results
os.chdir(curdir)
# Generate output file (in current folder)
# TODO: do not uncompress the warping field, it is too time consuming!
logger.info('Generate output files...')
if self.curved2straight:
generate_output_file(os.path.join(path_tmp, "tmp.curve2straight.nii.gz"),
os.path.join(self.path_output, "warp_curve2straight.nii.gz"), verbose)
if self.straight2curved:
generate_output_file(os.path.join(path_tmp, "tmp.straight2curve.nii.gz"),
os.path.join(self.path_output, "warp_straight2curve.nii.gz"), verbose)
# create ref_straight.nii.gz file that can be used by other SCT functions that need a straight reference space
if self.curved2straight:
copy(os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output, "straight_ref.nii.gz"))
# move straightened input file
if fname_output == '':
fname_straight = generate_output_file(os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output,
file_anat + "_straight" + ext_anat), verbose)
else:
fname_straight = generate_output_file(os.path.join(path_tmp, "tmp.anat_rigid_warp.nii.gz"),
os.path.join(self.path_output, fname_output),
verbose) # straightened anatomic
# Remove temporary files
if remove_temp_files:
logger.info('Remove temporary files...')
rmtree(path_tmp)
if self.accuracy_results:
logger.info('Maximum x-y error: {} mm'.format(self.max_distance_straightening))
logger.info('Accuracy of straightening (MSE): {} mm'.format(self.mse_straightening))
# display elapsed time
self.elapsed_time = int(np.round(time.time() - start_time))
return fname_straight
def main(argv=None):
"""Main function."""
parser = get_parser()
arguments = parser.parse_args(argv if argv else ['--help'])
verbose = arguments.v
set_global_loglevel(verbose=verbose)
fname_image = os.path.abspath(arguments.i)
contrast_type = arguments.c
ctr_algo = arguments.centerline
if arguments.brain is None:
if contrast_type in ['t2s', 'dwi']:
brain_bool = False
if contrast_type in ['t1', 't2']:
brain_bool = True
else:
brain_bool = bool(arguments.brain)
if bool(arguments.brain) and ctr_algo == 'svm':
printv('Please only use the flag "-brain 1" with "-centerline cnn".',
1, 'warning')
sys.exit(1)
kernel_size = arguments.kernel
if kernel_size == '3d' and contrast_type == 'dwi':
kernel_size = '2d'
printv(
'3D kernel model for dwi contrast is not available. 2D kernel model is used instead.',
type="warning")
if ctr_algo == 'file' and arguments.file_centerline is None:
printv(
'Please use the flag -file_centerline to indicate the centerline filename.',
1, 'warning')
sys.exit(1)
if arguments.file_centerline is not None:
manual_centerline_fname = arguments.file_centerline
ctr_algo = 'file'
else:
manual_centerline_fname = None
threshold = arguments.thr
if threshold is not None:
if threshold > 1.0 or (threshold < 0.0 and threshold != -1.0):
raise SyntaxError(
"Threshold should be between 0 and 1, or equal to -1 (no threshold)"
)
remove_temp_files = arguments.r
path_qc = arguments.qc
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
output_folder = arguments.ofolder
# check if input image is 2D or 3D
check_dim(fname_image, dim_lst=[2, 3])
# Segment image
im_image = Image(fname_image)
# note: below we pass im_image.copy() otherwise the field absolutepath becomes None after execution of this function
im_seg, im_image_RPI_upsamp, im_seg_RPI_upsamp = \
deep_segmentation_spinalcord(im_image.copy(), contrast_type, ctr_algo=ctr_algo,
ctr_file=manual_centerline_fname, brain_bool=brain_bool, kernel_size=kernel_size,
threshold_seg=threshold, remove_temp_files=remove_temp_files, verbose=verbose)
# Save segmentation
fname_seg = os.path.abspath(
os.path.join(
output_folder,
extract_fname(fname_image)[1] + '_seg' +
extract_fname(fname_image)[2]))
im_seg.save(fname_seg)
# Generate QC report
if path_qc is not None:
generate_qc(fname_image,
fname_seg=fname_seg,
args=sys.argv[1:],
path_qc=os.path.abspath(path_qc),
dataset=qc_dataset,
subject=qc_subject,
process='sct_deepseg_sc')
display_viewer_syntax([fname_image, fname_seg],
colormaps=['gray', 'red'],
opacities=['', '0.7'])
def reorient_data(self):
for f in self.fname_metric_lst:
os.rename(self.fname_metric_lst[f], add_suffix("".join(extract_fname(self.param.fname_im)[1:]), '_2reorient'))
im = Image(add_suffix("".join(extract_fname(self.param.fname_im)[1:]), '_2reorient')) \
.change_orientation(self.orientation_im) \
.save(self.fname_metric_lst[f])
def main(argv=None):
parser = get_parser()
arguments = parser.parse_args(argv)
verbose = arguments.v
set_global_loglevel(verbose=verbose)
# initializations
initz = ''
initcenter = ''
fname_initlabel = ''
file_labelz = 'labelz.nii.gz'
param = Param()
fname_in = os.path.abspath(arguments.i)
fname_seg = os.path.abspath(arguments.s)
contrast = arguments.c
path_template = os.path.abspath(arguments.t)
scale_dist = arguments.scale_dist
path_output = arguments.ofolder
param.path_qc = arguments.qc
if arguments.discfile is not None:
fname_disc = os.path.abspath(arguments.discfile)
else:
fname_disc = None
if arguments.initz is not None:
initz = arguments.initz
if len(initz) != 2:
raise ValueError('--initz takes two arguments: position in superior-inferior direction, label value')
if arguments.initcenter is not None:
initcenter = arguments.initcenter
# if user provided text file, parse and overwrite arguments
if arguments.initfile is not None:
file = open(arguments.initfile, 'r')
initfile = ' ' + file.read().replace('\n', '')
arg_initfile = initfile.split(' ')
for idx_arg, arg in enumerate(arg_initfile):
if arg == '-initz':
initz = [int(x) for x in arg_initfile[idx_arg + 1].split(',')]
if len(initz) != 2:
raise ValueError('--initz takes two arguments: position in superior-inferior direction, label value')
if arg == '-initcenter':
initcenter = int(arg_initfile[idx_arg + 1])
if arguments.initlabel is not None:
# get absolute path of label
fname_initlabel = os.path.abspath(arguments.initlabel)
if arguments.param is not None:
param.update(arguments.param[0])
remove_temp_files = arguments.r
clean_labels = arguments.clean_labels
laplacian = arguments.laplacian
path_tmp = tmp_create(basename="label_vertebrae")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder...', verbose)
Image(fname_in).save(os.path.join(path_tmp, "data.nii"))
Image(fname_seg).save(os.path.join(path_tmp, "segmentation.nii"))
# Go go temp folder
curdir = os.getcwd()
os.chdir(path_tmp)
# Straighten spinal cord
printv('\nStraighten spinal cord...', verbose)
# check if warp_curve2straight and warp_straight2curve already exist (i.e. no need to do it another time)
cache_sig = cache_signature(
input_files=[fname_in, fname_seg],
)
cachefile = os.path.join(curdir, "straightening.cache")
if cache_valid(cachefile, cache_sig) and os.path.isfile(os.path.join(curdir, "warp_curve2straight.nii.gz")) and os.path.isfile(os.path.join(curdir, "warp_straight2curve.nii.gz")) and os.path.isfile(os.path.join(curdir, "straight_ref.nii.gz")):
# if they exist, copy them into current folder
printv('Reusing existing warping field which seems to be valid', verbose, 'warning')
copy(os.path.join(curdir, "warp_curve2straight.nii.gz"), 'warp_curve2straight.nii.gz')
copy(os.path.join(curdir, "warp_straight2curve.nii.gz"), 'warp_straight2curve.nii.gz')
copy(os.path.join(curdir, "straight_ref.nii.gz"), 'straight_ref.nii.gz')
# apply straightening
s, o = run_proc(['sct_apply_transfo', '-i', 'data.nii', '-w', 'warp_curve2straight.nii.gz', '-d', 'straight_ref.nii.gz', '-o', 'data_straight.nii'])
else:
sct_straighten_spinalcord.main(argv=[
'-i', 'data.nii',
'-s', 'segmentation.nii',
'-r', str(remove_temp_files),
'-v', str(verbose),
])
cache_save(cachefile, cache_sig)
# resample to 0.5mm isotropic to match template resolution
printv('\nResample to 0.5mm isotropic...', verbose)
s, o = run_proc(['sct_resample', '-i', 'data_straight.nii', '-mm', '0.5x0.5x0.5', '-x', 'linear', '-o', 'data_straightr.nii'], verbose=verbose)
# Apply straightening to segmentation
# N.B. Output is RPI
printv('\nApply straightening to segmentation...', verbose)
run_proc('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation.nii',
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'segmentation_straight.nii',
'Linear'),
verbose=verbose,
is_sct_binary=True,
)
# Threshold segmentation at 0.5
img = Image('segmentation_straight.nii')
img.data = threshold(img.data, 0.5)
img.save()
# If disc label file is provided, label vertebrae using that file instead of automatically
if fname_disc:
# Apply straightening to disc-label
printv('\nApply straightening to disc labels...', verbose)
run_proc('sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
(fname_disc,
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'labeldisc_straight.nii.gz',
'label'),
verbose=verbose
)
label_vert('segmentation_straight.nii', 'labeldisc_straight.nii.gz', verbose=1)
else:
# create label to identify disc
printv('\nCreate label to identify disc...', verbose)
fname_labelz = os.path.join(path_tmp, file_labelz)
if initz or initcenter:
if initcenter:
# find z centered in FOV
nii = Image('segmentation.nii').change_orientation("RPI")
nx, ny, nz, nt, px, py, pz, pt = nii.dim # Get dimensions
z_center = int(np.round(nz / 2)) # get z_center
initz = [z_center, initcenter]
im_label = create_labels_along_segmentation(Image('segmentation.nii'), [(initz[0], initz[1])])
im_label.data = dilate(im_label.data, 3, 'ball')
im_label.save(fname_labelz)
elif fname_initlabel:
Image(fname_initlabel).save(fname_labelz)
else:
# automatically finds C2-C3 disc
im_data = Image('data.nii')
im_seg = Image('segmentation.nii')
if not remove_temp_files: # because verbose is here also used for keeping temp files
verbose_detect_c2c3 = 2
else:
verbose_detect_c2c3 = 0
im_label_c2c3 = detect_c2c3(im_data, im_seg, contrast, verbose=verbose_detect_c2c3)
ind_label = np.where(im_label_c2c3.data)
if not np.size(ind_label) == 0:
im_label_c2c3.data[ind_label] = 3
else:
printv('Automatic C2-C3 detection failed. Please provide manual label with sct_label_utils', 1, 'error')
sys.exit()
im_label_c2c3.save(fname_labelz)
# dilate label so it is not lost when applying warping
dilate(Image(fname_labelz), 3, 'ball').save(fname_labelz)
# Apply straightening to z-label
printv('\nAnd apply straightening to label...', verbose)
run_proc('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
(file_labelz,
'data_straightr.nii',
'warp_curve2straight.nii.gz',
'labelz_straight.nii.gz',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
# get z value and disk value to initialize labeling
printv('\nGet z and disc values from straight label...', verbose)
init_disc = get_z_and_disc_values_from_label('labelz_straight.nii.gz')
printv('.. ' + str(init_disc), verbose)
# apply laplacian filtering
if laplacian:
printv('\nApply Laplacian filter...', verbose)
img = Image("data_straightr.nii")
# apply std dev to each axis of the image
sigmas = [1 for i in range(len(img.data.shape))]
# adjust sigma based on voxel size
sigmas = [sigmas[i] / img.dim[i + 4] for i in range(3)]
# smooth data
img.data = laplacian(img.data, sigmas)
img.save()
# detect vertebral levels on straight spinal cord
init_disc[1] = init_disc[1] - 1
vertebral_detection('data_straightr.nii', 'segmentation_straight.nii', contrast, param, init_disc=init_disc,
verbose=verbose, path_template=path_template, path_output=path_output, scale_dist=scale_dist)
# un-straighten labeled spinal cord
printv('\nUn-straighten labeling...', verbose)
run_proc('isct_antsApplyTransforms -d 3 -i %s -r %s -t %s -o %s -n %s' %
('segmentation_straight_labeled.nii',
'segmentation.nii',
'warp_straight2curve.nii.gz',
'segmentation_labeled.nii',
'NearestNeighbor'),
verbose=verbose,
is_sct_binary=True,
)
if clean_labels:
# Clean labeled segmentation
printv('\nClean labeled segmentation (correct interpolation errors)...', verbose)
clean_labeled_segmentation('segmentation_labeled.nii', 'segmentation.nii', 'segmentation_labeled.nii')
# label discs
printv('\nLabel discs...', verbose)
printv('\nUn-straighten labeled discs...', verbose)
run_proc('sct_apply_transfo -i %s -d %s -w %s -o %s -x %s' %
('segmentation_straight_labeled_disc.nii',
'segmentation.nii',
'warp_straight2curve.nii.gz',
'segmentation_labeled_disc.nii',
'label'),
verbose=verbose,
is_sct_binary=True,
)
# come back
os.chdir(curdir)
# Generate output files
path_seg, file_seg, ext_seg = extract_fname(fname_seg)
fname_seg_labeled = os.path.join(path_output, file_seg + '_labeled' + ext_seg)
printv('\nGenerate output files...', verbose)
generate_output_file(os.path.join(path_tmp, "segmentation_labeled.nii"), fname_seg_labeled)
generate_output_file(os.path.join(path_tmp, "segmentation_labeled_disc.nii"), os.path.join(path_output, file_seg + '_labeled_discs' + ext_seg))
# copy straightening files in case subsequent SCT functions need them
generate_output_file(os.path.join(path_tmp, "warp_curve2straight.nii.gz"), os.path.join(path_output, "warp_curve2straight.nii.gz"), verbose=verbose)
generate_output_file(os.path.join(path_tmp, "warp_straight2curve.nii.gz"), os.path.join(path_output, "warp_straight2curve.nii.gz"), verbose=verbose)
generate_output_file(os.path.join(path_tmp, "straight_ref.nii.gz"), os.path.join(path_output, "straight_ref.nii.gz"), verbose=verbose)
# Remove temporary files
if remove_temp_files == 1:
printv('\nRemove temporary files...', verbose)
rmtree(path_tmp)
# Generate QC report
if param.path_qc is not None:
path_qc = os.path.abspath(arguments.qc)
qc_dataset = arguments.qc_dataset
qc_subject = arguments.qc_subject
labeled_seg_file = os.path.join(path_output, file_seg + '_labeled' + ext_seg)
generate_qc(fname_in, fname_seg=labeled_seg_file, args=argv, path_qc=os.path.abspath(path_qc),
dataset=qc_dataset, subject=qc_subject, process='sct_label_vertebrae')
display_viewer_syntax([fname_in, fname_seg_labeled], colormaps=['', 'subcortical'], opacities=['1', '0.5'])
def propseg(img_input, options_dict):
"""
:param img_input: source image, to be segmented
:param options_dict: arguments as dictionary
:return: segmented Image
"""
arguments = options_dict
fname_input_data = img_input.absolutepath
fname_data = os.path.abspath(fname_input_data)
contrast_type = arguments.c
contrast_type_conversion = {
't1': 't1',
't2': 't2',
't2s': 't2',
'dwi': 't1'
}
contrast_type_propseg = contrast_type_conversion[contrast_type]
# Starting building the command
cmd = ['isct_propseg', '-t', contrast_type_propseg]
if arguments.ofolder is not None:
folder_output = arguments.ofolder
else:
folder_output = './'
cmd += ['-o', folder_output]
if not os.path.isdir(folder_output) and os.path.exists(folder_output):
logger.error("output directory %s is not a valid directory" %
folder_output)
if not os.path.exists(folder_output):
os.makedirs(folder_output)
if arguments.down is not None:
cmd += ["-down", str(arguments.down)]
if arguments.up is not None:
cmd += ["-up", str(arguments.up)]
remove_temp_files = arguments.r
verbose = int(arguments.v)
init_sct(log_level=verbose, update=True) # Update log level
# Update for propseg binary
if verbose > 0:
cmd += ["-verbose"]
# Output options
if arguments.mesh is not None:
cmd += ["-mesh"]
if arguments.centerline_binary is not None:
cmd += ["-centerline-binary"]
if arguments.CSF is not None:
cmd += ["-CSF"]
if arguments.centerline_coord is not None:
cmd += ["-centerline-coord"]
if arguments.cross is not None:
cmd += ["-cross"]
if arguments.init_tube is not None:
cmd += ["-init-tube"]
if arguments.low_resolution_mesh is not None:
cmd += ["-low-resolution-mesh"]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_nii is not None:
# cmd += ["-detect-nii"]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_png is not None:
# cmd += ["-detect-png"]
# Helping options
use_viewer = None
use_optic = True # enabled by default
init_option = None
rescale_header = arguments.rescale
if arguments.init is not None:
init_option = float(arguments.init)
if init_option < 0:
printv(
'Command-line usage error: ' + str(init_option) +
" is not a valid value for '-init'", 1, 'error')
sys.exit(1)
if arguments.init_centerline is not None:
if str(arguments.init_centerline) == "viewer":
use_viewer = "centerline"
elif str(arguments.init_centerline) == "hough":
use_optic = False
else:
if rescale_header is not 1:
fname_labels_viewer = func_rescale_header(str(
arguments.init_centerline),
rescale_header,
verbose=verbose)
else:
fname_labels_viewer = str(arguments.init_centerline)
cmd += ["-init-centerline", fname_labels_viewer]
use_optic = False
if arguments.init_mask is not None:
if str(arguments.init_mask) == "viewer":
use_viewer = "mask"
else:
if rescale_header is not 1:
fname_labels_viewer = func_rescale_header(
str(arguments.init_mask), rescale_header)
else:
fname_labels_viewer = str(arguments.init_mask)
cmd += ["-init-mask", fname_labels_viewer]
use_optic = False
if arguments.mask_correction is not None:
cmd += ["-mask-correction", str(arguments.mask_correction)]
if arguments.radius is not None:
cmd += ["-radius", str(arguments.radius)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_n is not None:
# cmd += ["-detect-n", str(arguments.detect_n)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.detect_gap is not None:
# cmd += ["-detect-gap", str(arguments.detect_gap)]
# TODO: Not present. Why is this here? Was this renamed?
# if arguments.init_validation is not None:
# cmd += ["-init-validation"]
if arguments.nbiter is not None:
cmd += ["-nbiter", str(arguments.nbiter)]
if arguments.max_area is not None:
cmd += ["-max-area", str(arguments.max_area)]
if arguments.max_deformation is not None:
cmd += ["-max-deformation", str(arguments.max_deformation)]
if arguments.min_contrast is not None:
cmd += ["-min-contrast", str(arguments.min_contrast)]
if arguments.d is not None:
cmd += ["-d", str(arguments["-d"])]
if arguments.distance_search is not None:
cmd += ["-dsearch", str(arguments.distance_search)]
if arguments.alpha is not None:
cmd += ["-alpha", str(arguments.alpha)]
# check if input image is in 3D. Otherwise itk image reader will cut the 4D image in 3D volumes and only take the first one.
image_input = Image(fname_data)
image_input_rpi = image_input.copy().change_orientation('RPI')
nx, ny, nz, nt, px, py, pz, pt = image_input_rpi.dim
if nt > 1:
printv(
'ERROR: your input image needs to be 3D in order to be segmented.',
1, 'error')
path_data, file_data, ext_data = extract_fname(fname_data)
path_tmp = tmp_create(basename="label_vertebrae")
# rescale header (see issue #1406)
if rescale_header is not 1:
fname_data_propseg = func_rescale_header(fname_data, rescale_header)
else:
fname_data_propseg = fname_data
# add to command
cmd += ['-i', fname_data_propseg]
# if centerline or mask is asked using viewer
if use_viewer:
from spinalcordtoolbox.gui.base import AnatomicalParams
from spinalcordtoolbox.gui.centerline import launch_centerline_dialog
params = AnatomicalParams()
if use_viewer == 'mask':
params.num_points = 3
params.interval_in_mm = 15 # superior-inferior interval between two consecutive labels
params.starting_slice = 'midfovminusinterval'
if use_viewer == 'centerline':
# setting maximum number of points to a reasonable value
params.num_points = 20
params.interval_in_mm = 30
params.starting_slice = 'top'
im_data = Image(fname_data_propseg)
im_mask_viewer = zeros_like(im_data)
# im_mask_viewer.absolutepath = add_suffix(fname_data_propseg, '_labels_viewer')
controller = launch_centerline_dialog(im_data, im_mask_viewer, params)
fname_labels_viewer = add_suffix(fname_data_propseg, '_labels_viewer')
if not controller.saved:
printv(
'The viewer has been closed before entering all manual points. Please try again.',
1, 'error')
sys.exit(1)
# save labels
controller.as_niftii(fname_labels_viewer)
# add mask filename to parameters string
if use_viewer == "centerline":
cmd += ["-init-centerline", fname_labels_viewer]
elif use_viewer == "mask":
cmd += ["-init-mask", fname_labels_viewer]
# If using OptiC
elif use_optic:
image_centerline = optic.detect_centerline(image_input, contrast_type,
verbose)
fname_centerline_optic = os.path.join(path_tmp,
'centerline_optic.nii.gz')
image_centerline.save(fname_centerline_optic)
cmd += ["-init-centerline", fname_centerline_optic]
if init_option is not None:
if init_option > 1:
init_option /= (nz - 1)
cmd += ['-init', str(init_option)]
# enabling centerline extraction by default (needed by check_and_correct_segmentation() )
cmd += ['-centerline-binary']
# run propseg
status, output = run_proc(cmd,
verbose,
raise_exception=False,
is_sct_binary=True)
# check status is not 0
if not status == 0:
printv(
'Automatic cord detection failed. Please initialize using -init-centerline or -init-mask (see help)',
1, 'error')
sys.exit(1)
# build output filename
fname_seg = os.path.join(folder_output,
os.path.basename(add_suffix(fname_data, "_seg")))
fname_centerline = os.path.join(
folder_output, os.path.basename(add_suffix(fname_data, "_centerline")))
# in case header was rescaled, we need to update the output file names by removing the "_rescaled"
if rescale_header is not 1:
mv(
os.path.join(
folder_output,
add_suffix(os.path.basename(fname_data_propseg), "_seg")),
fname_seg)
mv(
os.path.join(
folder_output,
add_suffix(os.path.basename(fname_data_propseg),
"_centerline")), fname_centerline)
# if user was used, copy the labelled points to the output folder (they will then be scaled back)
if use_viewer:
fname_labels_viewer_new = os.path.join(
folder_output,
os.path.basename(add_suffix(fname_data, "_labels_viewer")))
copy(fname_labels_viewer, fname_labels_viewer_new)
# update variable (used later)
fname_labels_viewer = fname_labels_viewer_new
# check consistency of segmentation
if arguments.correct_seg:
check_and_correct_segmentation(fname_seg,
fname_centerline,
folder_output=folder_output,
threshold_distance=3.0,
remove_temp_files=remove_temp_files,
verbose=verbose)
# copy header from input to segmentation to make sure qform is the same
printv("Copy header input --> output(s) to make sure qform is the same.",
verbose)
list_fname = [fname_seg, fname_centerline]
if use_viewer:
list_fname.append(fname_labels_viewer)
for fname in list_fname:
im = Image(fname)
im.header = image_input.header
im.save(dtype='int8'
) # they are all binary masks hence fine to save as int8
return Image(fname_seg)
def resample_image(fname,
suffix='_resampled.nii.gz',
binary=False,
npx=0.3,
npy=0.3,
thr=0.0,
interpolation='spline'):
"""
Resampling function: add a padding, resample, crop the padding
:param fname: name of the image file to be resampled
:param suffix: suffix added to the original fname after resampling
:param binary: boolean, image is binary or not
:param npx: new pixel size in the x direction
:param npy: new pixel size in the y direction
:param thr: if the image is binary, it will be thresholded at thr (default=0) after the resampling
:param interpolation: type of interpolation used for the resampling
:return: file name after resampling (or original fname if it was already in the correct resolution)
"""
im_in = Image(fname)
orientation = im_in.orientation
if orientation != 'RPI':
fname = im_in.change_orientation(
im_in, 'RPI', generate_path=True).save().absolutepath
nx, ny, nz, nt, px, py, pz, pt = im_in.dim
if np.round(px, 2) != np.round(npx, 2) or np.round(py, 2) != np.round(
npy, 2):
name_resample = extract_fname(fname)[1] + suffix
if binary:
interpolation = 'nn'
if nz == 1:
# when data is 2d: we convert it to a 3d image in order to avoid conversion problem with 2d data
# TODO: check if this above problem is still present (now that we are using nibabel instead of nipy)
run_proc([
'sct_image', '-i', ','.join([fname, fname]), '-concat', 'z',
'-o', fname
])
run_proc([
'sct_resample', '-i', fname, '-mm',
str(npx) + 'x' + str(npy) + 'x' + str(pz), '-o', name_resample,
'-x', interpolation
])
if nz == 1: # when input data was 2d: re-convert data 3d-->2d
run_proc(['sct_image', '-i', name_resample, '-split', 'z'])
im_split = Image(
name_resample.split('.nii.gz')[0] + '_Z0000.nii.gz')
im_split.save(name_resample)
if binary:
run_proc([
'sct_maths', '-i', name_resample, '-bin',
str(thr), '-o', name_resample
])
if orientation != 'RPI':
name_resample = Image(name_resample) \
.change_orientation(orientation, generate_path=True) \
.save() \
.absolutepath
return name_resample
else:
if orientation != 'RPI':
fname = add_suffix(fname, "_RPI")
im_in = change_orientation(im_in, orientation).save(fname)
printv('Image resolution already ' + str(npx) + 'x' + str(npy) + 'xpz')
return fname
def moco(param):
"""
Main function that performs motion correction.
:param param:
:return:
"""
# retrieve parameters
file_data = param.file_data
file_target = param.file_target
folder_mat = param.mat_moco # output folder of mat file
todo = param.todo
suffix = param.suffix
verbose = param.verbose
# other parameters
file_mask = 'mask.nii'
printv('\nInput parameters:', param.verbose)
printv(' Input file ............ ' + file_data, param.verbose)
printv(' Reference file ........ ' + file_target, param.verbose)
printv(' Polynomial degree ..... ' + param.poly, param.verbose)
printv(' Smoothing kernel ...... ' + param.smooth, param.verbose)
printv(' Gradient step ......... ' + param.gradStep, param.verbose)
printv(' Metric ................ ' + param.metric, param.verbose)
printv(' Sampling .............. ' + param.sampling, param.verbose)
printv(' Todo .................. ' + todo, param.verbose)
printv(' Mask ................. ' + param.fname_mask, param.verbose)
printv(' Output mat folder ..... ' + folder_mat, param.verbose)
try:
os.makedirs(folder_mat)
except FileExistsError:
pass
# Get size of data
printv('\nData dimensions:', verbose)
im_data = Image(param.file_data)
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
printv(
(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' + str(nt)),
verbose)
# copy file_target to a temporary file
printv('\nCopy file_target to a temporary file...', verbose)
im_target = convert(Image(param.file_target))
im_target.save("target.nii.gz", mutable=True, verbose=0)
if not param.fname_mask == '':
file_target, _ = apply_mask_if_soft(file_target, param.fname_mask)
# If scan is sagittal, split src and target along Z (slice)
if param.is_sagittal:
dim_sag = 2 # TODO: find it
# z-split data (time series)
im_z_list = split_data(im_data, dim=dim_sag, squeeze_data=False)
file_data_splitZ = []
for im_z in im_z_list:
im_z.save(verbose=0)
file_data_splitZ.append(im_z.absolutepath)
# z-split target
im_targetz_list = split_data(Image(file_target),
dim=dim_sag,
squeeze_data=False)
file_target_splitZ = []
for im_targetz in im_targetz_list:
im_targetz.save(verbose=0)
file_target_splitZ.append(im_targetz.absolutepath)
# z-split mask (if exists)
if not param.fname_mask == '':
im_maskz_list = split_data(Image(file_mask),
dim=dim_sag,
squeeze_data=False)
file_mask_splitZ = []
for im_maskz in im_maskz_list:
im_maskz.save(verbose=0)
file_mask_splitZ.append(im_maskz.absolutepath)
# initialize file list for output matrices
file_mat = np.empty((nz, nt), dtype=object)
# axial orientation
else:
file_data_splitZ = [file_data] # TODO: make it absolute like above
file_target_splitZ = [file_target] # TODO: make it absolute like above
# initialize file list for output matrices
file_mat = np.empty((1, nt), dtype=object)
# deal with mask
if not param.fname_mask == '':
im_mask = convert(Image(param.fname_mask), squeeze_data=False)
im_mask.save(file_mask, mutable=True, verbose=0)
im_maskz_list = [Image(file_mask)
] # use a list with single element
# Loop across file list, where each file is either a 2D volume (if sagittal) or a 3D volume (otherwise)
# file_mat = tuple([[[] for i in range(nt)] for i in range(nz)])
file_data_splitZ_moco = []
printv(
'\nRegister. Loop across Z (note: there is only one Z if orientation is axial)'
)
for file in file_data_splitZ:
iz = file_data_splitZ.index(file)
# Split data along T dimension
# printv('\nSplit data along T dimension.', verbose)
im_z = Image(file)
list_im_zt = split_data(im_z, dim=3)
file_data_splitZ_splitT = []
for im_zt in list_im_zt:
im_zt.save(verbose=0)
file_data_splitZ_splitT.append(im_zt.absolutepath)
# file_data_splitT = file_data + '_T'
# Motion correction: initialization
index = np.arange(nt)
file_data_splitT_num = []
file_data_splitZ_splitT_moco = []
failed_transfo = [0 for i in range(nt)]
# Motion correction: Loop across T
for indice_index in sct_progress_bar(range(nt),
unit='iter',
unit_scale=False,
desc="Z=" + str(iz) + "/" +
str(len(file_data_splitZ) - 1),
ascii=False,
ncols=80):
# create indices and display stuff
it = index[indice_index]
file_mat[iz][it] = os.path.join(
folder_mat,
"mat.Z") + str(iz).zfill(4) + 'T' + str(it).zfill(4)
file_data_splitZ_splitT_moco.append(
add_suffix(file_data_splitZ_splitT[it], '_moco'))
# deal with masking (except in the 'apply' case, where masking is irrelevant)
input_mask = None
if not param.fname_mask == '' and not param.todo == 'apply':
file_data_splitZ_splitT[it], input_mask = apply_mask_if_soft(
file_data_splitZ_splitT[it], im_maskz_list[iz])
# run 3D registration
failed_transfo[it] = register(param,
file_data_splitZ_splitT[it],
file_target_splitZ[iz],
file_mat[iz][it],
file_data_splitZ_splitT_moco[it],
im_mask=input_mask)
# average registered volume with target image
# N.B. use weighted averaging: (target * nb_it + moco) / (nb_it + 1)
if param.iterAvg and indice_index < 10 and failed_transfo[
it] == 0 and not param.todo == 'apply':
im_targetz = Image(file_target_splitZ[iz])
data_targetz = im_targetz.data
data_mocoz = Image(file_data_splitZ_splitT_moco[it]).data
data_targetz = (data_targetz * (indice_index + 1) +
data_mocoz) / (indice_index + 2)
im_targetz.data = data_targetz
im_targetz.save(verbose=0)
# Replace failed transformation with the closest good one
fT = [i for i, j in enumerate(failed_transfo) if j == 1]
gT = [i for i, j in enumerate(failed_transfo) if j == 0]
for it in range(len(fT)):
abs_dist = [np.abs(gT[i] - fT[it]) for i in range(len(gT))]
if not abs_dist == []:
index_good = abs_dist.index(min(abs_dist))
printv(
' transfo #' + str(fT[it]) + ' --> use transfo #' +
str(gT[index_good]), verbose)
# copy transformation
copy(file_mat[iz][gT[index_good]] + 'Warp.nii.gz',
file_mat[iz][fT[it]] + 'Warp.nii.gz')
# apply transformation
sct_apply_transfo.main(argv=[
'-i', file_data_splitZ_splitT[fT[it]], '-d', file_target,
'-w', file_mat[iz][fT[it]] + 'Warp.nii.gz', '-o',
file_data_splitZ_splitT_moco[fT[it]], '-x', param.interp
])
else:
# exit program if no transformation exists.
printv(
'\nERROR in ' + os.path.basename(__file__) +
': No good transformation exist. Exit program.\n', verbose,
'error')
sys.exit(2)
# Merge data along T
file_data_splitZ_moco.append(add_suffix(file, suffix))
if todo != 'estimate':
im_data_splitZ_splitT_moco = [
Image(fname) for fname in file_data_splitZ_splitT_moco
]
im_out = concat_data(im_data_splitZ_splitT_moco, 3)
im_out.absolutepath = file_data_splitZ_moco[iz]
im_out.save(verbose=0)
# If sagittal, merge along Z
if param.is_sagittal:
# TODO: im_out.dim is incorrect: Z value is one
im_data_splitZ_moco = [Image(fname) for fname in file_data_splitZ_moco]
im_out = concat_data(im_data_splitZ_moco, 2)
dirname, basename, ext = extract_fname(file_data)
path_out = os.path.join(dirname, basename + suffix + ext)
im_out.absolutepath = path_out
im_out.save(verbose=0)
return file_mat, im_out
def moco_wrapper(param):
"""
Wrapper that performs motion correction.
:param param: ParamMoco class
:return: fname_moco
"""
file_data = 'data.nii' # corresponds to the full input data (e.g. dmri or fmri)
file_data_dirname, file_data_basename, file_data_ext = extract_fname(
file_data)
file_b0 = 'b0.nii'
file_datasub = 'datasub.nii' # corresponds to the full input data minus the b=0 scans (if param.is_diffusion=True)
file_datasubgroup = 'datasub-groups.nii' # concatenation of the average of each file_datasub
file_mask = 'mask.nii'
file_moco_params_csv = 'moco_params.tsv'
file_moco_params_x = 'moco_params_x.nii.gz'
file_moco_params_y = 'moco_params_y.nii.gz'
ext_data = '.nii.gz' # workaround "too many open files" by slurping the data
# TODO: check if .nii can be used
mat_final = 'mat_final'
# ext_mat = 'Warp.nii.gz' # warping field
# Start timer
start_time = time.time()
printv('\nInput parameters:', param.verbose)
printv(' Input file ............ ' + param.fname_data, param.verbose)
printv(' Group size ............ {}'.format(param.group_size),
param.verbose)
path_tmp = tmp_create(basename="moco")
# Copying input data to tmp folder
printv('\nCopying input data to tmp folder and convert to nii...',
param.verbose)
im_data = convert(Image(param.fname_data))
im_data.save(os.path.join(path_tmp, file_data),
mutable=True,
verbose=param.verbose)
if param.fname_mask != '':
im_mask = convert(Image(param.fname_mask))
im_mask.save(os.path.join(path_tmp, file_mask),
mutable=True,
verbose=param.verbose)
# Update field in param (because used later in another function, and param class will be passed)
param.fname_mask = file_mask
if param.fname_bvals != '':
_, _, ext_bvals = extract_fname(param.fname_bvals)
file_bvals = f"bvals.{ext_bvals}" # Use hardcoded name to avoid potential duplicate files when copying
copyfile(param.fname_bvals, os.path.join(path_tmp, file_bvals))
param.fname_bvals = file_bvals
if param.fname_bvecs != '':
_, _, ext_bvecs = extract_fname(param.fname_bvecs)
file_bvecs = f"bvecs.{ext_bvecs}" # Use hardcoded name to avoid potential duplicate files when copying
copyfile(param.fname_bvecs, os.path.join(path_tmp, file_bvecs))
param.fname_bvecs = file_bvecs
# Build absolute output path and go to tmp folder
curdir = os.getcwd()
path_out_abs = os.path.abspath(param.path_out)
os.chdir(path_tmp)
# Get dimensions of data
printv('\nGet dimensions of data...', param.verbose)
nx, ny, nz, nt, px, py, pz, pt = im_data.dim
printv(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz), param.verbose)
# Get orientation
printv('\nData orientation: ' + im_data.orientation, param.verbose)
if im_data.orientation[2] in 'LR':
param.is_sagittal = True
printv(' Treated as sagittal')
elif im_data.orientation[2] in 'IS':
param.is_sagittal = False
printv(' Treated as axial')
else:
param.is_sagittal = False
printv(
'WARNING: Orientation seems to be neither axial nor sagittal. Treated as axial.'
)
printv(
"\nSet suffix of transformation file name, which depends on the orientation:"
)
if param.is_sagittal:
param.suffix_mat = '0GenericAffine.mat'
printv(
"Orientation is sagittal, suffix is '{}'. The image is split across the R-L direction, and the "
"estimated transformation is a 2D affine transfo.".format(
param.suffix_mat))
else:
param.suffix_mat = 'Warp.nii.gz'
printv(
"Orientation is axial, suffix is '{}'. The estimated transformation is a 3D warping field, which is "
"composed of a stack of 2D Tx-Ty transformations".format(
param.suffix_mat))
# Adjust group size in case of sagittal scan
if param.is_sagittal and param.group_size != 1:
printv(
'For sagittal data group_size should be one for more robustness. Forcing group_size=1.',
1, 'warning')
param.group_size = 1
if param.is_diffusion:
# Identify b=0 and DWI images
index_b0, index_dwi, nb_b0, nb_dwi = \
sct_dmri_separate_b0_and_dwi.identify_b0(param.fname_bvecs, param.fname_bvals, param.bval_min,
param.verbose)
# check if dmri and bvecs are the same size
if not nb_b0 + nb_dwi == nt:
printv(
'\nERROR in ' + os.path.basename(__file__) +
': Size of data (' + str(nt) + ') and size of bvecs (' +
str(nb_b0 + nb_dwi) +
') are not the same. Check your bvecs file.\n', 1, 'error')
sys.exit(2)
# ==================================================================================================================
# Prepare data (mean/groups...)
# ==================================================================================================================
# Split into T dimension
printv('\nSplit along T dimension...', param.verbose)
im_data_split_list = split_data(im_data, 3)
for im in im_data_split_list:
x_dirname, x_basename, x_ext = extract_fname(im.absolutepath)
im.absolutepath = os.path.join(x_dirname, x_basename + ".nii.gz")
im.save()
if param.is_diffusion:
# Merge and average b=0 images
printv('\nMerge and average b=0 data...', param.verbose)
im_b0_list = []
for it in range(nb_b0):
im_b0_list.append(im_data_split_list[index_b0[it]])
im_b0 = concat_data(im_b0_list, 3).save(file_b0, verbose=0)
# Average across time
im_b0.mean(dim=3).save(add_suffix(file_b0, '_mean'))
n_moco = nb_dwi # set number of data to perform moco on (using grouping)
index_moco = index_dwi
# If not a diffusion scan, we will motion-correct all volumes
else:
n_moco = nt
index_moco = list(range(0, nt))
nb_groups = int(math.floor(n_moco / param.group_size))
# Generate groups indexes
group_indexes = []
for iGroup in range(nb_groups):
group_indexes.append(index_moco[(iGroup *
param.group_size):((iGroup + 1) *
param.group_size)])
# add the remaining images to a new last group (in case the total number of image is not divisible by group_size)
nb_remaining = n_moco % param.group_size # number of remaining images
if nb_remaining > 0:
nb_groups += 1
group_indexes.append(index_moco[len(index_moco) -
nb_remaining:len(index_moco)])
_, file_dwi_basename, file_dwi_ext = extract_fname(file_datasub)
# Group data
list_file_group = []
for iGroup in sct_progress_bar(range(nb_groups),
unit='iter',
unit_scale=False,
desc="Merge within groups",
ascii=False,
ncols=80):
# get index
index_moco_i = group_indexes[iGroup]
n_moco_i = len(index_moco_i)
# concatenate images across time, within this group
file_dwi_merge_i = os.path.join(file_dwi_basename + '_' + str(iGroup) +
ext_data)
im_dwi_list = []
for it in range(n_moco_i):
im_dwi_list.append(im_data_split_list[index_moco_i[it]])
im_dwi_out = concat_data(im_dwi_list, 3).save(file_dwi_merge_i,
verbose=0)
# Average across time
list_file_group.append(
os.path.join(file_dwi_basename + '_' + str(iGroup) + '_mean' +
ext_data))
im_dwi_out.mean(dim=3).save(list_file_group[-1])
# Merge across groups
printv('\nMerge across groups...', param.verbose)
# file_dwi_groups_means_merge = 'dwi_averaged_groups'
fname_dw_list = []
for iGroup in range(nb_groups):
fname_dw_list.append(list_file_group[iGroup])
im_dw_list = [Image(fname) for fname in fname_dw_list]
concat_data(im_dw_list, 3).save(file_datasubgroup, verbose=0)
# Cleanup
del im, im_data_split_list
# ==================================================================================================================
# Estimate moco
# ==================================================================================================================
# Initialize another class instance that will be passed on to the moco() function
param_moco = deepcopy(param)
if param.is_diffusion:
# Estimate moco on b0 groups
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Estimating motion on b=0 images...', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = 'b0.nii'
# Identify target image
if index_moco[0] != 0:
# If first DWI is not the first volume (most common), then there is a least one b=0 image before. In that
# case select it as the target image for registration of all b=0
param_moco.file_target = os.path.join(
file_data_dirname, file_data_basename + '_T' +
str(index_b0[index_moco[0] - 1]).zfill(4) + ext_data)
else:
# If first DWI is the first volume, then the target b=0 is the first b=0 from the index_b0.
param_moco.file_target = os.path.join(
file_data_dirname, file_data_basename + '_T' +
str(index_b0[0]).zfill(4) + ext_data)
# Run moco
param_moco.path_out = ''
param_moco.todo = 'estimate_and_apply'
param_moco.mat_moco = 'mat_b0groups'
file_mat_b0, _ = moco(param_moco)
# Estimate moco across groups
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Estimating motion across groups...', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = file_datasubgroup
param_moco.file_target = list_file_group[
0] # target is the first volume (closest to the first b=0 if DWI scan)
param_moco.path_out = ''
param_moco.todo = 'estimate_and_apply'
param_moco.mat_moco = 'mat_groups'
file_mat_datasub_group, _ = moco(param_moco)
# Spline Regularization along T
if param.spline_fitting:
# TODO: fix this scenario (haven't touched that code for a while-- it is probably buggy)
raise NotImplementedError()
# spline(mat_final, nt, nz, param.verbose, np.array(index_b0), param.plot_graph)
# ==================================================================================================================
# Apply moco
# ==================================================================================================================
# If group_size>1, assign transformation to each individual ungrouped 3d volume
if param.group_size > 1:
file_mat_datasub = []
for iz in range(len(file_mat_datasub_group)):
# duplicate by factor group_size the transformation file for each it
# example: [mat.Z0000T0001Warp.nii] --> [mat.Z0000T0001Warp.nii, mat.Z0000T0001Warp.nii] for group_size=2
file_mat_datasub.append(
functools.reduce(operator.iconcat,
[[i] * param.group_size
for i in file_mat_datasub_group[iz]], []))
else:
file_mat_datasub = file_mat_datasub_group
# Copy transformations to mat_final folder and rename them appropriately
copy_mat_files(nt, file_mat_datasub, index_moco, mat_final, param)
if param.is_diffusion:
copy_mat_files(nt, file_mat_b0, index_b0, mat_final, param)
# Apply moco on all dmri data
printv(
'\n-------------------------------------------------------------------------------',
param.verbose)
printv(' Apply moco', param.verbose)
printv(
'-------------------------------------------------------------------------------',
param.verbose)
param_moco.file_data = file_data
param_moco.file_target = list_file_group[
0] # reference for reslicing into proper coordinate system
param_moco.path_out = '' # TODO not used in moco()
param_moco.mat_moco = mat_final
param_moco.todo = 'apply'
file_mat_data, im_moco = moco(param_moco)
# copy geometric information from header
# NB: this is required because WarpImageMultiTransform in 2D mode wrongly sets pixdim(3) to "1".
im_moco.header = im_data.header
im_moco.save(verbose=0)
# Average across time
if param.is_diffusion:
# generate b0_moco_mean and dwi_moco_mean
args = [
'-i', im_moco.absolutepath, '-bvec', param.fname_bvecs, '-a', '1',
'-v', '0'
]
if not param.fname_bvals == '':
# if bvals file is provided
args += ['-bval', param.fname_bvals]
fname_b0, fname_b0_mean, fname_dwi, fname_dwi_mean = sct_dmri_separate_b0_and_dwi.main(
argv=args)
else:
fname_moco_mean = add_suffix(im_moco.absolutepath, '_mean')
im_moco.mean(dim=3).save(fname_moco_mean)
# Extract and output the motion parameters (doesn't work for sagittal orientation)
printv('Extract motion parameters...')
if param.output_motion_param:
if param.is_sagittal:
printv(
'Motion parameters cannot be generated for sagittal images.',
1, 'warning')
else:
files_warp_X, files_warp_Y = [], []
moco_param = []
for fname_warp in file_mat_data[0]:
# Cropping the image to keep only one voxel in the XY plane
im_warp = Image(fname_warp + param.suffix_mat)
im_warp.data = np.expand_dims(np.expand_dims(
im_warp.data[0, 0, :, :, :], axis=0),
axis=0)
# These three lines allow to generate one file instead of two, containing X, Y and Z moco parameters
#fname_warp_crop = fname_warp + '_crop_' + ext_mat
# files_warp.append(fname_warp_crop)
# im_warp.save(fname_warp_crop)
# Separating the three components and saving X and Y only (Z is equal to 0 by default).
im_warp_XYZ = multicomponent_split(im_warp)
fname_warp_crop_X = fname_warp + '_crop_X_' + param.suffix_mat
im_warp_XYZ[0].save(fname_warp_crop_X)
files_warp_X.append(fname_warp_crop_X)
fname_warp_crop_Y = fname_warp + '_crop_Y_' + param.suffix_mat
im_warp_XYZ[1].save(fname_warp_crop_Y)
files_warp_Y.append(fname_warp_crop_Y)
# Calculating the slice-wise average moco estimate to provide a QC file
moco_param.append([
np.mean(np.ravel(im_warp_XYZ[0].data)),
np.mean(np.ravel(im_warp_XYZ[1].data))
])
# These two lines allow to generate one file instead of two, containing X, Y and Z moco parameters
# im_warp = [Image(fname) for fname in files_warp]
# im_warp_concat = concat_data(im_warp, dim=3)
# im_warp_concat.save('fmri_moco_params.nii')
# Concatenating the moco parameters into a time series for X and Y components.
im_warp_X = [Image(fname) for fname in files_warp_X]
im_warp_concat = concat_data(im_warp_X, dim=3)
im_warp_concat.save(file_moco_params_x)
im_warp_Y = [Image(fname) for fname in files_warp_Y]
im_warp_concat = concat_data(im_warp_Y, dim=3)
im_warp_concat.save(file_moco_params_y)
# Writing a TSV file with the slicewise average estimate of the moco parameters. Useful for QC
with open(file_moco_params_csv, 'wt', newline='') as out_file:
tsv_writer = csv.writer(out_file, delimiter='\t')
tsv_writer.writerow(['X', 'Y'])
for mocop in moco_param:
tsv_writer.writerow([mocop[0], mocop[1]])
# Generate output files
printv('\nGenerate output files...', param.verbose)
fname_moco = os.path.join(
path_out_abs,
add_suffix(os.path.basename(param.fname_data), param.suffix))
generate_output_file(im_moco.absolutepath, fname_moco)
if param.is_diffusion:
generate_output_file(fname_b0_mean, add_suffix(fname_moco, '_b0_mean'))
generate_output_file(fname_dwi_mean,
add_suffix(fname_moco, '_dwi_mean'))
else:
generate_output_file(fname_moco_mean, add_suffix(fname_moco, '_mean'))
if os.path.exists(file_moco_params_csv):
generate_output_file(file_moco_params_x,
os.path.join(path_out_abs, file_moco_params_x),
squeeze_data=False)
generate_output_file(file_moco_params_y,
os.path.join(path_out_abs, file_moco_params_y),
squeeze_data=False)
generate_output_file(file_moco_params_csv,
os.path.join(path_out_abs, file_moco_params_csv))
# Delete temporary files
if param.remove_temp_files == 1:
printv('\nDelete temporary files...', param.verbose)
rmtree(path_tmp, verbose=param.verbose)
# come back to working directory
os.chdir(curdir)
# display elapsed time
elapsed_time = time.time() - start_time
printv('\nElapsed time: ' + str(int(np.round(elapsed_time))) + 's',
param.verbose)
fname_moco = os.path.join(
param.path_out,
add_suffix(os.path.basename(param.fname_data), param.suffix))
return fname_moco