def validation(self):
name_ref_gm_seg = sct.extract_fname(self.ref_gm_seg)
im_ref_gm_seg = Image('../' + self.ref_gm_seg)
res_gm_seg_bin = Image('../' + self.res_names['gm_seg'])
res_wm_seg_bin = Image('../' + self.res_names['wm_seg'])
sct.run('cp ../' + self.ref_gm_seg + ' ./ref_gm_seg.nii.gz')
im_ref_wm_seg = inverse_gmseg_to_wmseg(im_ref_gm_seg, Image('../' + self.sc_seg_fname), 'ref_gm_seg')
im_ref_wm_seg.file_name = 'ref_wm_seg'
im_ref_wm_seg.ext = '.nii.gz'
im_ref_wm_seg.save()
if self.param.res_type == 'prob':
res_gm_seg_bin.data = np.asarray((res_gm_seg_bin.data >= 0.5).astype(int))
res_wm_seg_bin.data = np.asarray((res_wm_seg_bin.data >= 0.50001).astype(int))
res_gm_seg_bin.path = './'
res_gm_seg_bin.file_name = 'res_gm_seg_bin'
res_gm_seg_bin.ext = '.nii.gz'
res_gm_seg_bin.save()
res_wm_seg_bin.path = './'
res_wm_seg_bin.file_name = 'res_wm_seg_bin'
res_wm_seg_bin.ext = '.nii.gz'
res_wm_seg_bin.save()
try:
status_gm, output_gm = sct.run('sct_dice_coefficient ref_gm_seg.nii.gz res_gm_seg_bin.nii.gz -2d-slices 2', error_exit='warning', raise_exception=True)
except Exception:
sct.run('c3d res_gm_seg_bin.nii.gz ref_gm_seg.nii.gz -reslice-identity -o ref_in_res_space_gm.nii.gz ')
status_gm, output_gm = sct.run('sct_dice_coefficient ref_in_res_space_gm.nii.gz res_gm_seg_bin.nii.gz -2d-slices 2', error_exit='warning')
try:
status_wm, output_wm = sct.run('sct_dice_coefficient ref_wm_seg.nii.gz res_wm_seg_bin.nii.gz -2d-slices 2', error_exit='warning', raise_exception=True)
except Exception:
sct.run('c3d res_wm_seg_bin.nii.gz ref_wm_seg.nii.gz -reslice-identity -o ref_in_res_space_wm.nii.gz ')
status_wm, output_wm = sct.run('sct_dice_coefficient ref_in_res_space_wm.nii.gz res_wm_seg_bin.nii.gz -2d-slices 2', error_exit='warning')
dice_name = 'dice_' + self.param.res_type + '.txt'
dice_fic = open('../' + dice_name, 'w')
if self.param.res_type == 'prob':
dice_fic.write('WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n')
dice_fic.write('\n--------------------------------------------------------------\nDice coefficient on the Gray Matter segmentation:\n')
dice_fic.write(output_gm)
dice_fic.write('\n\n--------------------------------------------------------------\nDice coefficient on the White Matter segmentation:\n')
dice_fic.write(output_wm)
dice_fic.close()
# sct.run(' mv ./' + dice_name + ' ../')
return dice_name
def validation(self):
ext = '.nii.gz'
validation_dir = 'validation'
sct.run('mkdir ' + validation_dir)
# loading the images
im_ref_gm_seg = Image('../' + self.ref_gm_seg_fname)
im_ref_wm_seg = inverse_gmseg_to_wmseg(
im_ref_gm_seg,
Image('../' + self.sc_seg_fname),
im_ref_gm_seg.path + im_ref_gm_seg.file_name,
save=False)
res_gm_seg_bin = self.gm_seg.res_gm_seg.copy()
res_wm_seg_bin = self.gm_seg.res_wm_seg.copy()
if self.param.res_type == 'prob':
res_gm_seg_bin.data = np.asarray(
(res_gm_seg_bin.data >= 0.5).astype(int))
res_wm_seg_bin.data = np.asarray(
(res_wm_seg_bin.data >= 0.50001).astype(int))
mask = Image(self.preprocessed.square_mask)
# doing the validation
os.chdir(validation_dir)
im_ref_gm_seg.path = './'
im_ref_gm_seg.file_name = 'ref_gm_seg'
im_ref_gm_seg.ext = ext
im_ref_gm_seg.save()
ref_gm_seg_new_name = resample_image(im_ref_gm_seg.file_name + ext,
npx=self.preprocessed.resample_to,
npy=self.preprocessed.resample_to,
binary=True)
im_ref_gm_seg = Image(ref_gm_seg_new_name)
sct.run('rm ' + ref_gm_seg_new_name)
im_ref_wm_seg.path = './'
im_ref_wm_seg.file_name = 'ref_wm_seg'
im_ref_wm_seg.ext = ext
im_ref_wm_seg.save()
ref_wm_seg_new_name = resample_image(im_ref_wm_seg.file_name + ext,
npx=self.preprocessed.resample_to,
npy=self.preprocessed.resample_to,
binary=True)
im_ref_wm_seg = Image(ref_wm_seg_new_name)
sct.run('rm ' + ref_wm_seg_new_name)
ref_orientation = im_ref_gm_seg.orientation
im_ref_gm_seg.change_orientation('IRP')
im_ref_wm_seg.change_orientation('IRP')
im_ref_gm_seg.crop_and_stack(mask, save=False)
im_ref_wm_seg.crop_and_stack(mask, save=False)
im_ref_gm_seg.change_orientation('RPI')
im_ref_wm_seg.change_orientation('RPI')
# saving the images to call the validation functions
res_gm_seg_bin.path = './'
res_gm_seg_bin.file_name = 'res_gm_seg_bin'
res_gm_seg_bin.ext = ext
res_gm_seg_bin.save()
res_wm_seg_bin.path = './'
res_wm_seg_bin.file_name = 'res_wm_seg_bin'
res_wm_seg_bin.ext = ext
res_wm_seg_bin.save()
im_ref_gm_seg.path = './'
im_ref_gm_seg.file_name = 'ref_gm_seg'
im_ref_gm_seg.ext = ext
im_ref_gm_seg.save()
im_ref_wm_seg.path = './'
im_ref_wm_seg.file_name = 'ref_wm_seg'
im_ref_wm_seg.ext = ext
im_ref_wm_seg.save()
sct.run('sct_orientation -i ' + res_gm_seg_bin.file_name + ext +
' -s RPI')
res_gm_seg_bin.file_name += '_RPI'
sct.run('sct_orientation -i ' + res_wm_seg_bin.file_name + ext +
' -s RPI')
res_wm_seg_bin.file_name += '_RPI'
res_gm_seg_bin = Image(res_gm_seg_bin.file_name + ext)
im_ref_gm_seg.hdr.set_zooms(
res_gm_seg_bin.hdr.get_zooms()) # correcting the pix dimension
im_ref_gm_seg.save()
res_wm_seg_bin = Image(res_wm_seg_bin.file_name + ext)
im_ref_wm_seg.hdr.set_zooms(
res_wm_seg_bin.hdr.get_zooms()) # correcting the pix dimension
im_ref_wm_seg.save()
# Dice
try:
status_gm, output_gm = sct.run(
'sct_dice_coefficient ' + im_ref_gm_seg.file_name + ext + ' ' +
res_gm_seg_bin.file_name + ext + ' -2d-slices 2',
error_exit='warning',
raise_exception=True)
except Exception:
sct.run('c3d ' + res_gm_seg_bin.file_name + ext + ' ' +
im_ref_gm_seg.file_name + ext + ' -reslice-identity -o ' +
im_ref_gm_seg.file_name + '_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_gm_seg.file_name + '_in_res_space' +
ext + ' -thr 0.1 ' + im_ref_gm_seg.file_name +
'_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_gm_seg.file_name + '_in_res_space' +
ext + ' -bin ' + im_ref_gm_seg.file_name +
'_in_res_space' + ext)
status_gm, output_gm = sct.run(
'sct_dice_coefficient ' + im_ref_gm_seg.file_name +
'_in_res_space' + ext + ' ' + res_gm_seg_bin.file_name + ext +
' -2d-slices 2',
error_exit='warning')
try:
status_wm, output_wm = sct.run(
'sct_dice_coefficient ' + im_ref_wm_seg.file_name + ext + ' ' +
res_wm_seg_bin.file_name + ext + ' -2d-slices 2',
error_exit='warning',
raise_exception=True)
except Exception:
sct.run('c3d ' + res_wm_seg_bin.file_name + ext + ' ' +
im_ref_wm_seg.file_name + ext + ' -reslice-identity -o ' +
im_ref_wm_seg.file_name + '_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_wm_seg.file_name + '_in_res_space' +
ext + ' -thr 0.1 ' + im_ref_wm_seg.file_name +
'_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_wm_seg.file_name + '_in_res_space' +
ext + ' -bin ' + im_ref_wm_seg.file_name +
'_in_res_space' + ext)
status_wm, output_wm = sct.run(
'sct_dice_coefficient ' + im_ref_wm_seg.file_name +
'_in_res_space' + ext + ' ' + res_wm_seg_bin.file_name + ext +
' -2d-slices 2',
error_exit='warning')
dice_name = 'dice_' + sct.extract_fname(
self.target_fname)[1] + '_' + self.param.res_type + '.txt'
dice_fic = open('../../' + dice_name, 'w')
if self.param.res_type == 'prob':
dice_fic.write(
'WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n'
)
dice_fic.write(
'\n--------------------------------------------------------------\n'
'Dice coefficient on the Gray Matter segmentation:\n')
dice_fic.write(output_gm)
dice_fic.write(
'\n\n--------------------------------------------------------------\n'
'Dice coefficient on the White Matter segmentation:\n')
dice_fic.write(output_wm)
dice_fic.close()
# sct.run(' mv ./' + dice_name + ' ../')
hd_name = 'hd_' + sct.extract_fname(
self.target_fname)[1] + '_' + self.param.res_type + '.txt'
sct.run('sct_compute_hausdorff_distance.py -i ' +
res_gm_seg_bin.file_name + ext + ' -r ' +
im_ref_gm_seg.file_name + ext + ' -t 1 -o ' + hd_name +
' -v ' + str(self.param.verbose))
sct.run('mv ./' + hd_name + ' ../../')
os.chdir('..')
return dice_name, hd_name
def validation(self):
name_ref_gm_seg = sct.extract_fname(self.ref_gm_seg)
im_ref_gm_seg = Image("../" + self.ref_gm_seg)
res_gm_seg_bin = Image("../" + self.res_names["gm_seg"])
res_wm_seg_bin = Image("../" + self.res_names["wm_seg"])
sct.run("cp ../" + self.ref_gm_seg + " ./ref_gm_seg.nii.gz")
im_ref_wm_seg = inverse_gmseg_to_wmseg(im_ref_gm_seg, Image("../" + self.sc_seg_fname), "ref_gm_seg")
im_ref_wm_seg.file_name = "ref_wm_seg"
im_ref_wm_seg.ext = ".nii.gz"
im_ref_wm_seg.save()
if self.param.res_type == "prob":
res_gm_seg_bin.data = np.asarray((res_gm_seg_bin.data >= 0.5).astype(int))
res_wm_seg_bin.data = np.asarray((res_wm_seg_bin.data >= 0.50001).astype(int))
res_gm_seg_bin.path = "./"
res_gm_seg_bin.file_name = "res_gm_seg_bin"
res_gm_seg_bin.ext = ".nii.gz"
res_gm_seg_bin.save()
res_wm_seg_bin.path = "./"
res_wm_seg_bin.file_name = "res_wm_seg_bin"
res_wm_seg_bin.ext = ".nii.gz"
res_wm_seg_bin.save()
try:
status_gm, output_gm = sct.run(
"sct_dice_coefficient ref_gm_seg.nii.gz res_gm_seg_bin.nii.gz -2d-slices 2",
error_exit="warning",
raise_exception=True,
)
except Exception:
sct.run("c3d res_gm_seg_bin.nii.gz ref_gm_seg.nii.gz -reslice-identity -o ref_in_res_space_gm.nii.gz ")
status_gm, output_gm = sct.run(
"sct_dice_coefficient ref_in_res_space_gm.nii.gz res_gm_seg_bin.nii.gz -2d-slices 2",
error_exit="warning",
)
try:
status_wm, output_wm = sct.run(
"sct_dice_coefficient ref_wm_seg.nii.gz res_wm_seg_bin.nii.gz -2d-slices 2",
error_exit="warning",
raise_exception=True,
)
except Exception:
sct.run("c3d res_wm_seg_bin.nii.gz ref_wm_seg.nii.gz -reslice-identity -o ref_in_res_space_wm.nii.gz ")
status_wm, output_wm = sct.run(
"sct_dice_coefficient ref_in_res_space_wm.nii.gz res_wm_seg_bin.nii.gz -2d-slices 2",
error_exit="warning",
)
dice_name = "dice_" + self.param.res_type + ".txt"
dice_fic = open("../" + dice_name, "w")
if self.param.res_type == "prob":
dice_fic.write(
"WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n"
)
dice_fic.write(
"\n--------------------------------------------------------------\nDice coefficient on the Gray Matter segmentation:\n"
)
dice_fic.write(output_gm)
dice_fic.write(
"\n\n--------------------------------------------------------------\nDice coefficient on the White Matter segmentation:\n"
)
dice_fic.write(output_wm)
dice_fic.close()
# sct.run(' mv ./' + dice_name + ' ../')
return dice_name
def resample():
# extract resampling factor
sct.printv('\nParse resampling factor...', param.verbose)
factor_split = param.factor.split('x')
factor = [float(factor_split[i]) for i in range(len(factor_split))]
# check if it has three values
if not len(factor) == 3:
sct.printv('\nERROR: factor should have three dimensions. E.g., 2x2x1.\n', 1, 'error')
else:
fx, fy, fz = [float(factor_split[i]) for i in range(len(factor_split))]
# Extract path/file/extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
path_out, file_out, ext_out = path_data, file_data, ext_data
if param.fname_out != '':
file_out = sct.extract_fname(param.fname_out)[1]
else:
file_out.append(param.file_suffix)
input_im = Image(param.fname_data)
# Get dimensions of data
sct.printv('\nGet dimensions of data...', param.verbose)
nx, ny, nz, nt, px, py, pz, pt = input_im.dim
sct.printv(' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz)+ ' x ' + str(nt), param.verbose)
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
#TODO : adapt for 2D too or change description
sct.run('ERROR (sct_resample): Dimension of input data is different from 3 or 4. Exit program', param.verbose, 'error')
# Calculate new dimensions
sct.printv('\nCalculate new dimensions...', param.verbose)
nx_new = int(round(nx*fx))
ny_new = int(round(ny*fy))
nz_new = int(round(nz*fz))
px_new = px/fx
py_new = py/fy
pz_new = pz/fz
sct.printv(' ' + str(nx_new) + ' x ' + str(ny_new) + ' x ' + str(nz_new)+ ' x ' + str(nt), param.verbose)
zooms = input_im.hdr.get_zooms()[:3]
affine = input_im.hdr.get_base_affine()
new_zooms = (px_new, py_new, pz_new)
if type(param.interpolation) == int:
order = param.interpolation
elif type(param.interpolation) == str and param.interpolation in param.x_to_order.keys():
order = param.x_to_order[param.interpolation]
else:
order = 1
sct.printv('WARNING: wrong input for the interpolation. Using default value = trilinear', param.verbose, 'warning')
new_data, new_affine = dp_iso.reslice(input_im.data, affine, zooms, new_zooms, mode=param.mode, order=order)
new_im = Image(param=new_data)
new_im.absolutepath = path_out+file_out+ext_out
new_im.path = path_out
new_im.file_name = file_out
new_im.ext = ext_out
zooms_to_set = list(new_zooms)
if dim == 4:
zooms_to_set.append(nt)
new_im.hdr = input_im.hdr
new_im.hdr.set_zooms(zooms_to_set)
new_im.save()
# to view results
sct.printv('\nDone! To view results, type:', param.verbose)
sct.printv('fslview '+param.fname_out+' &', param.verbose, 'info')
print
def resample():
# extract resampling factor
sct.printv('\nParse resampling factor...', param.verbose)
factor_split = param.factor.split('x')
factor = [float(factor_split[i]) for i in range(len(factor_split))]
# check if it has three values
if not len(factor) == 3:
sct.printv(
'\nERROR: factor should have three dimensions. E.g., 2x2x1.\n', 1,
'error')
else:
fx, fy, fz = [float(factor_split[i]) for i in range(len(factor_split))]
# Extract path/file/extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
path_out, file_out, ext_out = path_data, file_data, ext_data
if param.fname_out != '':
file_out = sct.extract_fname(param.fname_out)[1]
else:
file_out.append(param.file_suffix)
input_im = Image(param.fname_data)
# Get dimensions of data
sct.printv('\nGet dimensions of data...', param.verbose)
nx, ny, nz, nt, px, py, pz, pt = input_im.dim
sct.printv(
' ' + str(nx) + ' x ' + str(ny) + ' x ' + str(nz) + ' x ' + str(nt),
param.verbose)
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
#TODO : adapt for 2D too or change description
sct.run(
'ERROR (sct_resample): Dimension of input data is different from 3 or 4. Exit program',
param.verbose, 'error')
# Calculate new dimensions
sct.printv('\nCalculate new dimensions...', param.verbose)
nx_new = int(round(nx * fx))
ny_new = int(round(ny * fy))
nz_new = int(round(nz * fz))
px_new = px / fx
py_new = py / fy
pz_new = pz / fz
sct.printv(
' ' + str(nx_new) + ' x ' + str(ny_new) + ' x ' + str(nz_new) +
' x ' + str(nt), param.verbose)
zooms = input_im.hdr.get_zooms()[:3]
affine = input_im.hdr.get_base_affine()
new_zooms = (px_new, py_new, pz_new)
if type(param.interpolation) == int:
order = param.interpolation
elif type(param.interpolation
) == str and param.interpolation in param.x_to_order.keys():
order = param.x_to_order[param.interpolation]
else:
order = 1
sct.printv(
'WARNING: wrong input for the interpolation. Using default value = trilinear',
param.verbose, 'warning')
new_data, new_affine = dp_iso.reslice(input_im.data,
affine,
zooms,
new_zooms,
mode=param.mode,
order=order)
new_im = Image(param=new_data)
new_im.absolutepath = path_out + file_out + ext_out
new_im.path = path_out
new_im.file_name = file_out
new_im.ext = ext_out
zooms_to_set = list(new_zooms)
if dim == 4:
zooms_to_set.append(nt)
new_im.hdr = input_im.hdr
new_im.hdr.set_zooms(zooms_to_set)
new_im.save()
# to view results
sct.printv('\nDone! To view results, type:', param.verbose)
sct.printv('fslview ' + param.fname_out + ' &', param.verbose, 'info')
print
def resample():
# extract resampling factor
sct.printv('\nParse resampling factor...', param.verbose)
new_size_split = param.new_size.split('x')
new_size = [float(new_size_split[i]) for i in range(len(new_size_split))]
# check if it has three values
if not len(new_size) == 3:
sct.printv('\nERROR: new size should have three dimensions. E.g., 2x2x1.\n', 1, 'error')
else:
ns_x, ns_y, ns_z = new_size
# Extract path/file/extension
path_data, file_data, ext_data = sct.extract_fname(param.fname_data)
path_out, file_out, ext_out = '', file_data, ext_data
if param.fname_out != '':
path_out, file_out, ext_out = sct.extract_fname(param.fname_out)
else:
file_out += param.file_suffix
param.fname_out = path_out+file_out+ext_out
input_im = Image(param.fname_data)
# Get dimensions of data
sct.printv('\nGet dimensions of data...', param.verbose)
nx, ny, nz, nt, px, py, pz, pt = input_im.dim
sct.printv(' ' + str(px) + ' x ' + str(py) + ' x ' + str(pz)+ ' x ' + str(pt)+'mm', param.verbose)
dim = 4 # by default, will be adjusted later
if nt == 1:
dim = 3
if nz == 1:
dim = 2
sct.run('ERROR (sct_resample): Dimension of input data is different from 3 or 4. Exit program', param.verbose, 'error')
# Calculate new dimensions
sct.printv('\nCalculate new dimensions...', param.verbose)
if param.new_size_type == 'factor':
px_new = px/ns_x
py_new = py/ns_y
pz_new = pz/ns_z
elif param.new_size_type == 'vox':
px_new = px*nx/ns_x
py_new = py*ny/ns_y
pz_new = pz*nz/ns_z
else:
px_new = ns_x
py_new = ns_y
pz_new = ns_z
sct.printv(' ' + str(px_new) + ' x ' + str(py_new) + ' x ' + str(pz_new)+ ' x ' + str(pt)+'mm', param.verbose)
zooms = (px, py, pz) # input_im.hdr.get_zooms()[:3]
affine = input_im.hdr.get_qform() # get_base_affine()
new_zooms = (px_new, py_new, pz_new)
if type(param.interpolation) == int:
order = param.interpolation
elif type(param.interpolation) == str and param.interpolation in param.x_to_order.keys():
order = param.x_to_order[param.interpolation]
else:
order = 1
sct.printv('WARNING: wrong input for the interpolation. Using default value = linear', param.verbose, 'warning')
new_data, new_affine = dp_iso.reslice(input_im.data, affine, zooms, new_zooms, mode=param.mode, order=order)
new_im = Image(param=new_data)
new_im.absolutepath = param.fname_out
new_im.path = path_out
new_im.file_name = file_out
new_im.ext = ext_out
zooms_to_set = list(new_zooms)
if dim == 4:
zooms_to_set.append(nt)
new_im.hdr = input_im.hdr
new_im.hdr.set_zooms(zooms_to_set)
# Set the new sform and qform:
new_im.hdr.set_sform(new_affine)
new_im.hdr.set_qform(new_affine)
new_im.save()
# to view results
sct.printv('\nDone! To view results, type:', param.verbose)
sct.printv('fslview '+param.fname_out+' &', param.verbose, 'info')
def validation(self):
ext = '.nii.gz'
validation_dir = 'validation'
sct.run('mkdir ' + validation_dir)
# loading the images
im_ref_gm_seg = Image('../' + self.ref_gm_seg_fname)
im_ref_wm_seg = inverse_gmseg_to_wmseg(im_ref_gm_seg, Image('../' + self.sc_seg_fname), im_ref_gm_seg.path + im_ref_gm_seg.file_name, save=False)
res_gm_seg_bin = self.gm_seg.res_gm_seg.copy()
res_wm_seg_bin = self.gm_seg.res_wm_seg.copy()
if self.param.res_type == 'prob':
res_gm_seg_bin.data = np.asarray((res_gm_seg_bin.data >= 0.5).astype(int))
res_wm_seg_bin.data = np.asarray((res_wm_seg_bin.data >= 0.50001).astype(int))
mask = Image(self.preprocessed.square_mask)
# doing the validation
os.chdir(validation_dir)
im_ref_gm_seg.path = './'
im_ref_gm_seg.file_name = 'ref_gm_seg'
im_ref_gm_seg.ext = ext
im_ref_gm_seg.save()
ref_gm_seg_new_name = resample_image(im_ref_gm_seg.file_name + ext, npx=self.preprocessed.resample_to, npy=self.preprocessed.resample_to, binary=True)
im_ref_gm_seg = Image(ref_gm_seg_new_name)
sct.run('rm ' + ref_gm_seg_new_name)
im_ref_wm_seg.path = './'
im_ref_wm_seg.file_name = 'ref_wm_seg'
im_ref_wm_seg.ext = ext
im_ref_wm_seg.save()
ref_wm_seg_new_name = resample_image(im_ref_wm_seg.file_name + ext, npx=self.preprocessed.resample_to, npy=self.preprocessed.resample_to, binary=True)
im_ref_wm_seg = Image(ref_wm_seg_new_name)
sct.run('rm ' + ref_wm_seg_new_name)
ref_orientation = im_ref_gm_seg.orientation
im_ref_gm_seg.change_orientation('IRP')
im_ref_wm_seg.change_orientation('IRP')
im_ref_gm_seg.crop_and_stack(mask, save=False)
im_ref_wm_seg.crop_and_stack(mask, save=False)
im_ref_gm_seg.change_orientation('RPI')
im_ref_wm_seg.change_orientation('RPI')
# saving the images to call the validation functions
res_gm_seg_bin.path = './'
res_gm_seg_bin.file_name = 'res_gm_seg_bin'
res_gm_seg_bin.ext = ext
res_gm_seg_bin.save()
res_wm_seg_bin.path = './'
res_wm_seg_bin.file_name = 'res_wm_seg_bin'
res_wm_seg_bin.ext = ext
res_wm_seg_bin.save()
im_ref_gm_seg.path = './'
im_ref_gm_seg.file_name = 'ref_gm_seg'
im_ref_gm_seg.ext = ext
im_ref_gm_seg.save()
im_ref_wm_seg.path = './'
im_ref_wm_seg.file_name = 'ref_wm_seg'
im_ref_wm_seg.ext = ext
im_ref_wm_seg.save()
sct.run('sct_orientation -i ' + res_gm_seg_bin.file_name + ext + ' -s RPI')
res_gm_seg_bin.file_name += '_RPI'
sct.run('sct_orientation -i ' + res_wm_seg_bin.file_name + ext + ' -s RPI')
res_wm_seg_bin.file_name += '_RPI'
res_gm_seg_bin = Image(res_gm_seg_bin.file_name + ext)
im_ref_gm_seg.hdr.set_zooms(res_gm_seg_bin.hdr.get_zooms()) # correcting the pix dimension
im_ref_gm_seg.save()
res_wm_seg_bin = Image(res_wm_seg_bin.file_name + ext)
im_ref_wm_seg.hdr.set_zooms(res_wm_seg_bin.hdr.get_zooms()) # correcting the pix dimension
im_ref_wm_seg.save()
# Dice
try:
status_gm, output_gm = sct.run('sct_dice_coefficient ' + im_ref_gm_seg.file_name + ext + ' ' + res_gm_seg_bin.file_name + ext + ' -2d-slices 2', error_exit='warning', raise_exception=True)
except Exception:
sct.run('c3d ' + res_gm_seg_bin.file_name + ext + ' ' + im_ref_gm_seg.file_name + ext + ' -reslice-identity -o ' + im_ref_gm_seg.file_name + '_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_gm_seg.file_name + '_in_res_space' + ext + ' -thr 0.1 ' + im_ref_gm_seg.file_name + '_in_res_space' + ext )
sct.run('fslmaths ' + im_ref_gm_seg.file_name + '_in_res_space' + ext + ' -bin ' + im_ref_gm_seg.file_name + '_in_res_space' + ext )
status_gm, output_gm = sct.run('sct_dice_coefficient ' + im_ref_gm_seg.file_name + '_in_res_space' + ext + ' ' + res_gm_seg_bin.file_name + ext + ' -2d-slices 2', error_exit='warning')
try:
status_wm, output_wm = sct.run('sct_dice_coefficient ' + im_ref_wm_seg.file_name + ext + ' ' + res_wm_seg_bin.file_name + ext + ' -2d-slices 2', error_exit='warning', raise_exception=True)
except Exception:
sct.run('c3d ' + res_wm_seg_bin.file_name + ext + ' ' + im_ref_wm_seg.file_name + ext + ' -reslice-identity -o ' + im_ref_wm_seg.file_name + '_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_wm_seg.file_name + '_in_res_space' + ext + ' -thr 0.1 ' + im_ref_wm_seg.file_name + '_in_res_space' + ext)
sct.run('fslmaths ' + im_ref_wm_seg.file_name + '_in_res_space' + ext + ' -bin ' + im_ref_wm_seg.file_name + '_in_res_space' + ext)
status_wm, output_wm = sct.run('sct_dice_coefficient ' + im_ref_wm_seg.file_name + '_in_res_space' + ext + ' ' + res_wm_seg_bin.file_name + ext + ' -2d-slices 2', error_exit='warning')
dice_name = 'dice_' + sct.extract_fname(self.target_fname)[1] + '_' + self.param.res_type + '.txt'
dice_fic = open('../../' + dice_name, 'w')
if self.param.res_type == 'prob':
dice_fic.write('WARNING : the probabilistic segmentations were binarized with a threshold at 0.5 to compute the dice coefficient \n')
dice_fic.write('\n--------------------------------------------------------------\n'
'Dice coefficient on the Gray Matter segmentation:\n')
dice_fic.write(output_gm)
dice_fic.write('\n\n--------------------------------------------------------------\n'
'Dice coefficient on the White Matter segmentation:\n')
dice_fic.write(output_wm)
dice_fic.close()
# sct.run(' mv ./' + dice_name + ' ../')
hd_name = 'hd_' + sct.extract_fname(self.target_fname)[1] + '_' + self.param.res_type + '.txt'
sct.run('sct_compute_hausdorff_distance.py -i ' + res_gm_seg_bin.file_name + ext + ' -r ' + im_ref_gm_seg.file_name + ext + ' -t 1 -o ' + hd_name + ' -v ' + str(self.param.verbose))
sct.run('mv ./' + hd_name + ' ../../')
os.chdir('..')
return dice_name, hd_name
