def register_data(im_src, im_dest, param_reg, path_copy_warp=None, rm_tmp=True):
'''
Parameters
----------
im_src: class Image: source image
im_dest: class Image: destination image
param_reg: str: registration parameter
path_copy_warp: path: path to copy the warping fields
Returns: im_src_reg: class Image: source image registered on destination image
-------
'''
# im_src and im_dest are already preprocessed (in theory: im_dest = mean_image)
# binarize images to get seg
im_src_seg = binarize(im_src, thr_min=1, thr_max=1)
im_dest_seg = binarize(im_dest)
# create tmp dir and go in it
tmp_dir = tmp_create()
os.chdir(tmp_dir)
# save image and seg
fname_src = 'src.nii.gz'
im_src.setFileName(fname_src)
im_src.save()
fname_src_seg = 'src_seg.nii.gz'
im_src_seg.setFileName(fname_src_seg)
im_src_seg.save()
fname_dest = 'dest.nii.gz'
im_dest.setFileName(fname_dest)
im_dest.save()
fname_dest_seg = 'dest_seg.nii.gz'
im_dest_seg.setFileName(fname_dest_seg)
im_dest_seg.save()
# do registration using param_reg
sct_register_multimodal.main(args=['-i', fname_src,
'-d', fname_dest,
'-iseg', fname_src_seg,
'-dseg', fname_dest_seg,
'-param', param_reg])
# get registration result
fname_src_reg = add_suffix(fname_src, '_reg')
im_src_reg = Image(fname_src_reg)
# get out of tmp dir
os.chdir('..')
# copy warping fields
if path_copy_warp is not None and os.path.isdir(os.path.abspath(path_copy_warp)):
path_copy_warp = os.path.abspath(path_copy_warp)
file_src = extract_fname(fname_src)[1]
file_dest = extract_fname(fname_dest)[1]
fname_src2dest = 'warp_' + file_src +'2' + file_dest +'.nii.gz'
fname_dest2src = 'warp_' + file_dest +'2' + file_src +'.nii.gz'
shutil.copy(tmp_dir +'/' + fname_src2dest, path_copy_warp + '/')
shutil.copy(tmp_dir + '/' + fname_dest2src, path_copy_warp + '/')
if rm_tmp:
# remove tmp dir
shutil.rmtree(tmp_dir)
# return res image
return im_src_reg, fname_src2dest, fname_dest2src
def validation(self):
tmp_dir_val = 'tmp_validation/'
if not os.path.exists(tmp_dir_val):
os.mkdir(tmp_dir_val)
# copy data into tmp dir val
shutil.copy(self.param_seg.fname_manual_gmseg, tmp_dir_val)
shutil.copy(self.param_seg.fname_seg, tmp_dir_val)
os.chdir(tmp_dir_val)
fname_manual_gmseg = ''.join(extract_fname(self.param_seg.fname_manual_gmseg)[1:])
fname_seg = ''.join(extract_fname(self.param_seg.fname_seg)[1:])
im_gmseg = self.im_res_gmseg.copy()
im_wmseg = self.im_res_wmseg.copy()
if self.param_seg.type_seg == 'prob':
im_gmseg = binarize(im_gmseg, thr_max=0.5, thr_min=0.5)
im_wmseg = binarize(im_wmseg, thr_max=0.5, thr_min=0.5)
fname_gmseg = 'res_gmseg.nii.gz'
im_gmseg.setFileName(fname_gmseg)
im_gmseg.save()
fname_wmseg = 'res_wmseg.nii.gz'
im_wmseg.setFileName(fname_wmseg)
im_wmseg.save()
# get manual WM seg:
fname_manual_wmseg = 'manual_wmseg.nii.gz'
sct_maths.main(args=['-i', fname_seg,
'-sub', fname_manual_gmseg,
'-o', fname_manual_wmseg])
# compute DC:
try:
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg + ' -d ' + fname_gmseg + ' -2d-slices 2', error_exit='warning', raise_exception=True)
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg + ' -d ' + fname_wmseg + ' -2d-slices 2', error_exit='warning', raise_exception=True)
except Exception:
# put ref and res in the same space if needed
fname_manual_gmseg_corrected = add_suffix(fname_manual_gmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_gmseg,
'-d', fname_gmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_gmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_gmseg_corrected])
#
fname_manual_wmseg_corrected = add_suffix(fname_manual_wmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_wmseg,
'-d', fname_wmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_wmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_wmseg_corrected])
# recompute DC
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg_corrected + ' -d ' + fname_gmseg + ' -2d-slices 2', error_exit='warning', raise_exception=True)
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg_corrected + ' -d ' + fname_wmseg + ' -2d-slices 2', error_exit='warning', raise_exception=True)
# save results to a text file
fname_dc = 'dice_coefficient_' + extract_fname(self.param_seg.fname_im)[1] + '.txt'
file_dc = open(fname_dc, 'w')
if self.param_seg.type_seg == 'prob':
file_dc.write('WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n')
file_dc.write('\n--------------------------------------------------------------\nDice coefficient on the Gray Matter segmentation:\n')
file_dc.write(output_gm)
file_dc.write('\n\n--------------------------------------------------------------\nDice coefficient on the White Matter segmentation:\n')
file_dc.write(output_wm)
file_dc.close()
# compute HD and MD:
fname_hd = 'hausdorff_dist_' + extract_fname(self.param_seg.fname_im)[1] + '.txt'
run('sct_compute_hausdorff_distance -i ' + fname_gmseg + ' -d ' + fname_manual_gmseg + ' -thinning 1 -o ' + fname_hd + ' -v ' + str(self.param.verbose))
# get out of tmp dir to copy results to output folder
os.chdir('../..')
shutil.copy(self.tmp_dir + tmp_dir_val + '/' + fname_dc, self.param_seg.path_results)
shutil.copy(self.tmp_dir + tmp_dir_val + '/' + fname_hd, self.param_seg.path_results)
os.chdir(self.tmp_dir)
if self.param.rm_tmp:
shutil.rmtree(tmp_dir_val)
def validation(self):
tmp_dir_val = sct.tmp_create(basename="segment_graymatter_validation")
# copy data into tmp dir val
sct.copy(self.param_seg.fname_manual_gmseg, tmp_dir_val)
sct.copy(self.param_seg.fname_seg, tmp_dir_val)
curdir = os.getcwd()
os.chdir(tmp_dir_val)
fname_manual_gmseg = os.path.basename(self.param_seg.fname_manual_gmseg)
fname_seg = os.path.basename(self.param_seg.fname_seg)
im_gmseg = self.im_res_gmseg.copy()
im_wmseg = self.im_res_wmseg.copy()
if self.param_seg.type_seg == 'prob':
im_gmseg = binarize(im_gmseg, thr_max=0.5, thr_min=0.5)
im_wmseg = binarize(im_wmseg, thr_max=0.5, thr_min=0.5)
fname_gmseg = 'res_gmseg.nii.gz'
im_gmseg.save(fname_gmseg)
fname_wmseg = 'res_wmseg.nii.gz'
im_wmseg.save(fname_wmseg)
# get manual WM seg:
fname_manual_wmseg = 'manual_wmseg.nii.gz'
sct_maths.main(args=['-i', fname_seg,
'-sub', fname_manual_gmseg,
'-o', fname_manual_wmseg])
# compute DC:
try:
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg + ' -d ' + fname_gmseg + ' -2d-slices 2')
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg + ' -d ' + fname_wmseg + ' -2d-slices 2')
except Exception:
# put ref and res in the same space if needed
fname_manual_gmseg_corrected = add_suffix(fname_manual_gmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_gmseg,
'-d', fname_gmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_gmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_gmseg_corrected])
#
fname_manual_wmseg_corrected = add_suffix(fname_manual_wmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_wmseg,
'-d', fname_wmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_wmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_wmseg_corrected])
# recompute DC
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg_corrected + ' -d ' + fname_gmseg + ' -2d-slices 2')
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg_corrected + ' -d ' + fname_wmseg + ' -2d-slices 2')
# save results to a text file
fname_dc = 'dice_coefficient_' + extract_fname(self.param_seg.fname_im)[1] + '.txt'
file_dc = open(fname_dc, 'w')
if self.param_seg.type_seg == 'prob':
file_dc.write('WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n')
file_dc.write('\n--------------------------------------------------------------\nDice coefficient on the Gray Matter segmentation:\n')
file_dc.write(output_gm)
file_dc.write('\n\n--------------------------------------------------------------\nDice coefficient on the White Matter segmentation:\n')
file_dc.write(output_wm)
file_dc.close()
# compute HD and MD:
fname_hd = 'hausdorff_dist_' + extract_fname(self.param_seg.fname_im)[1] + '.txt'
run('sct_compute_hausdorff_distance -i ' + fname_gmseg + ' -d ' + fname_manual_gmseg + ' -thinning 1 -o ' + fname_hd + ' -v ' + str(self.param.verbose))
# get out of tmp dir to copy results to output folder
os.chdir(curdir)
sct.copy(os.path.join(self.tmp_dir, tmp_dir_val, fname_dc), self.param_seg.path_results)
sct.copy(os.path.join(self.tmp_dir, tmp_dir_val, fname_hd), self.param_seg.path_results)
if self.param.rm_tmp:
sct.rmtree(tmp_dir_val)
def register_data(im_src,
im_dest,
param_reg,
path_copy_warp=None,
rm_tmp=True):
'''
Parameters
----------
im_src: class Image: source image
im_dest: class Image: destination image
param_reg: str: registration parameter
path_copy_warp: path: path to copy the warping fields
Returns: im_src_reg: class Image: source image registered on destination image
-------
'''
# im_src and im_dest are already preprocessed (in theory: im_dest = mean_image)
# binarize images to get seg
im_src_seg = binarize(im_src, thr_min=1, thr_max=1)
im_dest_seg = binarize(im_dest)
# create tmp dir and go in it
tmp_dir = sct.tmp_create()
curdir = os.getcwd()
os.chdir(tmp_dir)
# save image and seg
fname_src = 'src.nii.gz'
im_src.save(fname_src)
fname_src_seg = 'src_seg.nii.gz'
im_src_seg.save(fname_src_seg)
fname_dest = 'dest.nii.gz'
im_dest.save(fname_dest)
fname_dest_seg = 'dest_seg.nii.gz'
im_dest_seg.save(fname_dest_seg)
# do registration using param_reg
sct_register_multimodal.main(args=[
'-i', fname_src, '-d', fname_dest, '-iseg', fname_src_seg, '-dseg',
fname_dest_seg, '-param', param_reg
])
# get registration result
fname_src_reg = add_suffix(fname_src, '_reg')
im_src_reg = Image(fname_src_reg)
# get out of tmp dir
os.chdir(curdir)
# copy warping fields
if path_copy_warp is not None and os.path.isdir(
os.path.abspath(path_copy_warp)):
path_copy_warp = os.path.abspath(path_copy_warp)
file_src = extract_fname(fname_src)[1]
file_dest = extract_fname(fname_dest)[1]
fname_src2dest = 'warp_' + file_src + '2' + file_dest + '.nii.gz'
fname_dest2src = 'warp_' + file_dest + '2' + file_src + '.nii.gz'
sct.copy(os.path.join(tmp_dir, fname_src2dest), path_copy_warp)
sct.copy(os.path.join(tmp_dir, fname_dest2src), path_copy_warp)
if rm_tmp:
# remove tmp dir
sct.rmtree(tmp_dir)
# return res image
return im_src_reg, fname_src2dest, fname_dest2src
def validation(self):
tmp_dir_val = 'tmp_validation/'
if not os.path.exists(tmp_dir_val):
os.mkdir(tmp_dir_val)
# copy data into tmp dir val
shutil.copy(self.param_seg.fname_manual_gmseg, tmp_dir_val)
shutil.copy(self.param_seg.fname_seg, tmp_dir_val)
os.chdir(tmp_dir_val)
fname_manual_gmseg = ''.join(extract_fname(self.param_seg.fname_manual_gmseg)[1:])
fname_seg = ''.join(extract_fname(self.param_seg.fname_seg)[1:])
im_gmseg = self.im_res_gmseg.copy()
im_wmseg = self.im_res_wmseg.copy()
if self.param_seg.type_seg == 'prob':
im_gmseg = binarize(im_gmseg, thr_max=0.5, thr_min=0.5)
im_wmseg = binarize(im_wmseg, thr_max=0.5, thr_min=0.5)
fname_gmseg = 'res_gmseg.nii.gz'
im_gmseg.setFileName(fname_gmseg)
im_gmseg.save()
fname_wmseg = 'res_wmseg.nii.gz'
im_wmseg.setFileName(fname_wmseg)
im_wmseg.save()
# get manual WM seg:
fname_manual_wmseg = 'manual_wmseg.nii.gz'
sct_maths.main(args=['-i', fname_seg,
'-sub', fname_manual_gmseg,
'-o', fname_manual_wmseg])
## compute DC:
try:
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg + ' -d ' + fname_gmseg + ' -2d-slices 2',error_exit='warning', raise_exception=True)
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg + ' -d ' + fname_wmseg + ' -2d-slices 2',error_exit='warning', raise_exception=True)
except Exception:
# put ref and res in the same space if needed
fname_manual_gmseg_corrected = add_suffix(fname_manual_gmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_gmseg,
'-d', fname_gmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_gmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_gmseg_corrected])
#
fname_manual_wmseg_corrected = add_suffix(fname_manual_wmseg, '_reg')
sct_register_multimodal.main(args=['-i', fname_manual_wmseg,
'-d', fname_wmseg,
'-identity', '1'])
sct_maths.main(args=['-i', fname_manual_wmseg_corrected,
'-bin', '0.1',
'-o', fname_manual_wmseg_corrected])
# recompute DC
status_gm, output_gm = run('sct_dice_coefficient -i ' + fname_manual_gmseg_corrected + ' -d ' + fname_gmseg + ' -2d-slices 2',error_exit='warning', raise_exception=True)
status_wm, output_wm = run('sct_dice_coefficient -i ' + fname_manual_wmseg_corrected + ' -d ' + fname_wmseg + ' -2d-slices 2',error_exit='warning', raise_exception=True)
# save results to a text file
fname_dc = 'dice_coefficient_' + sct.extract_fname(self.param_seg.fname_im)[1] + '.txt'
file_dc = open(fname_dc, 'w')
if self.param_seg.type_seg == 'prob':
file_dc.write('WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n')
file_dc.write('\n--------------------------------------------------------------\nDice coefficient on the Gray Matter segmentation:\n')
file_dc.write(output_gm)
file_dc.write('\n\n--------------------------------------------------------------\nDice coefficient on the White Matter segmentation:\n')
file_dc.write(output_wm)
file_dc.close()
## compute HD and MD:
fname_hd = 'hausdorff_dist_' + sct.extract_fname(self.param_seg.fname_im)[1] + '.txt'
run('sct_compute_hausdorff_distance -i ' + fname_gmseg + ' -d ' + fname_manual_gmseg + ' -thinning 1 -o ' + fname_hd + ' -v ' + str(self.param.verbose))
# get out of tmp dir to copy results to output folder
os.chdir('../..')
shutil.copy(self.tmp_dir+tmp_dir_val+'/'+fname_dc, self.param_seg.path_results)
shutil.copy(self.tmp_dir + tmp_dir_val + '/' + fname_hd, self.param_seg.path_results)
os.chdir(self.tmp_dir)
if self.param.rm_tmp:
shutil.rmtree(tmp_dir_val)
