def segment_3d(model_fname, contrast_type, im):
"""Perform segmentation with 3D convolutions."""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_3d = {
't2': {
'size': (48, 48, 48),
'mean': 871.309,
'std': 557.916
},
't2_ax': {
'size': (48, 48, 48),
'mean': 835.592,
'std': 528.386
},
't2s': {
'size': (48, 48, 48),
'mean': 1011.31,
'std': 678.985
}
}
# load 3d model
seg_model = load_trained_model(model_fname)
out_data = np.zeros(im.data.shape)
# segment the spinal cord
z_patch_size = dct_patch_3d[contrast_type]['size'][2]
z_step_keep = list(range(0, im.data.shape[2], z_patch_size))
for zz in z_step_keep:
if zz == z_step_keep[
-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_3d[contrast_type]['size'])
z_patch_extracted = im.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im.data[:, :, zz:z_patch_size + zz]
if np.any(
patch_im
): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = _normalize_data(patch_im,
dct_patch_3d[contrast_type]['mean'],
dct_patch_3d[contrast_type]['std'])
patch_pred_proba = seg_model.predict(np.expand_dims(
np.expand_dims(patch_norm, 0), 0),
batch_size=BATCH_SIZE)
pred_seg_th = (patch_pred_proba > 0.1).astype(int)[0, 0, :, :, :]
if zz == z_step_keep[-1]:
out_data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out_data[:, :, zz:z_patch_size + zz] = pred_seg_th
out = msct_image.zeros_like(im, dtype=np.uint8)
out.data = out_data
return out.copy()
def segment_3d(model_fname, contrast_type, im_in):
"""Perform segmentation with 3D convolutions."""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_sc_3d = {'t2': {'size': (64, 64, 48), 'mean': 65.8562, 'std': 59.7999},
't2s': {'size': (96, 96, 48), 'mean': 87.0212, 'std': 64.425},
't1': {'size': (64, 64, 48), 'mean': 88.5001, 'std': 66.275}}
# load 3d model
seg_model = load_trained_model(model_fname)
out = zeros_like(im_in, dtype=np.uint8)
# segment the spinal cord
z_patch_size = dct_patch_sc_3d[contrast_type]['size'][2]
z_step_keep = list(range(0, im_in.data.shape[2], z_patch_size))
for zz in z_step_keep:
if zz == z_step_keep[-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_sc_3d[contrast_type]['size'])
z_patch_extracted = im_in.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im_in.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im_in.data[:, :, zz:z_patch_size + zz]
if np.any(patch_im): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = \
_normalize_data(patch_im, dct_patch_sc_3d[contrast_type]['mean'], dct_patch_sc_3d[contrast_type]['std'])
patch_pred_proba = \
seg_model.predict(np.expand_dims(np.expand_dims(patch_norm, 0), 0), batch_size=BATCH_SIZE)
pred_seg_th = (patch_pred_proba > 0.5).astype(int)[0, 0, :, :, :]
x_cOm, y_cOm = None, None
for zz_pp in range(z_patch_size):
pred_seg_pp = post_processing_slice_wise(pred_seg_th[:, :, zz_pp], x_cOm, y_cOm)
pred_seg_th[:, :, zz_pp] = pred_seg_pp
x_cOm, y_cOm = center_of_mass(pred_seg_pp)
x_cOm, y_cOm = np.round(x_cOm), np.round(y_cOm)
if zz == z_step_keep[-1]:
out.data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out.data[:, :, zz:z_patch_size + zz] = pred_seg_th
return out.data
def segment_3d(model_fname, contrast_type, im_in):
"""Perform segmentation with 3D convolutions."""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_sc_3d = {'t2': {'size': (64, 64, 48), 'mean': 65.8562, 'std': 59.7999},
't2s': {'size': (96, 96, 48), 'mean': 87.0212, 'std': 64.425},
't1': {'size': (64, 64, 48), 'mean': 88.5001, 'std': 66.275}}
# load 3d model
seg_model = load_trained_model(model_fname)
out = zeros_like(im_in, dtype=np.uint8)
# segment the spinal cord
z_patch_size = dct_patch_sc_3d[contrast_type]['size'][2]
z_step_keep = list(range(0, im_in.data.shape[2], z_patch_size))
for zz in z_step_keep:
if zz == z_step_keep[-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_sc_3d[contrast_type]['size'])
z_patch_extracted = im_in.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im_in.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im_in.data[:, :, zz:z_patch_size + zz]
if np.any(patch_im): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = \
_normalize_data(patch_im, dct_patch_sc_3d[contrast_type]['mean'], dct_patch_sc_3d[contrast_type]['std'])
patch_pred_proba = \
seg_model.predict(np.expand_dims(np.expand_dims(patch_norm, 0), 0), batch_size=BATCH_SIZE)
pred_seg_th = (patch_pred_proba > 0.5).astype(int)[0, 0, :, :, :]
x_cOm, y_cOm = None, None
for zz_pp in range(z_patch_size):
pred_seg_pp = post_processing_slice_wise(pred_seg_th[:, :, zz_pp], x_cOm, y_cOm)
pred_seg_th[:, :, zz_pp] = pred_seg_pp
x_cOm, y_cOm = center_of_mass(pred_seg_pp)
x_cOm, y_cOm = np.round(x_cOm), np.round(y_cOm)
if zz == z_step_keep[-1]:
out.data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out.data[:, :, zz:z_patch_size + zz] = pred_seg_th
return out.data
def segment_3d(model_fname, contrast_type, im_in):
"""
Perform segmentation with 3D convolutions.
:return: seg_crop.data: ndarray float32: Output prediction
"""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_sc_3d = {'t2': {'size': (64, 64, 48), 'mean': 65.8562, 'std': 59.7999},
't2s': {'size': (96, 96, 48), 'mean': 87.0212, 'std': 64.425},
't1': {'size': (64, 64, 48), 'mean': 88.5001, 'std': 66.275}}
# load 3d model
seg_model = load_trained_model(model_fname)
out = zeros_like(im_in, dtype=np.float32)
# segment the spinal cord
z_patch_size = dct_patch_sc_3d[contrast_type]['size'][2]
z_step_keep = list(range(0, im_in.data.shape[2], z_patch_size))
# TODO: use sct_progress_bar
for zz in z_step_keep:
if zz == z_step_keep[-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_sc_3d[contrast_type]['size'])
z_patch_extracted = im_in.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im_in.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im_in.data[:, :, zz:z_patch_size + zz]
if np.any(patch_im): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = \
_normalize_data(patch_im, dct_patch_sc_3d[contrast_type]['mean'], dct_patch_sc_3d[contrast_type]['std'])
patch_pred_proba = \
seg_model.predict(np.expand_dims(np.expand_dims(patch_norm, 0), 0), batch_size=BATCH_SIZE)
# pred_seg_th = (patch_pred_proba > 0.5).astype(int)[0, 0, :, :, :]
pred_seg_th = patch_pred_proba[0, 0, :, :, :] # TODO: clarified variable (this is not thresholded!)
# TODO: add comment about what the code is doing below
if zz == z_step_keep[-1]:
out.data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out.data[:, :, zz:z_patch_size + zz] = pred_seg_th
return out.data
def segment_3d(model_fname, contrast_type, im):
"""Perform segmentation with 3D convolutions."""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_3d = {'t2': {'size': (48, 48, 48), 'mean': 871.309, 'std': 557.916},
't2_ax': {'size': (48, 48, 48), 'mean': 835.592, 'std': 528.386},
't2s': {'size': (48, 48, 48), 'mean': 1011.31, 'std': 678.985}}
# load 3d model
seg_model = load_trained_model(model_fname)
out_data = np.zeros(im.data.shape)
# segment the spinal cord
z_patch_size = dct_patch_3d[contrast_type]['size'][2]
z_step_keep = list(range(0, im.data.shape[2], z_patch_size))
for zz in z_step_keep:
if zz == z_step_keep[-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_3d[contrast_type]['size'])
z_patch_extracted = im.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im.data[:, :, zz:z_patch_size + zz]
if np.any(patch_im): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = _normalize_data(patch_im, dct_patch_3d[contrast_type]['mean'], dct_patch_3d[contrast_type]['std'])
patch_pred_proba = seg_model.predict(np.expand_dims(np.expand_dims(patch_norm, 0), 0), batch_size=BATCH_SIZE)
pred_seg_th = (patch_pred_proba > 0.1).astype(int)[0, 0, :, :, :]
if zz == z_step_keep[-1]:
out_data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out_data[:, :, zz:z_patch_size + zz] = pred_seg_th
out = msct_image.zeros_like(im, dtype=np.uint8)
out.data = out_data
return out.copy()
def segment_3d(model_fname, contrast_type, fname_in, fname_out):
"""Perform segmentation with 3D convolutions."""
from spinalcordtoolbox.deepseg_sc.cnn_models_3d import load_trained_model
dct_patch_sc_3d = {
't2': {
'size': (64, 64, 48),
'mean': 65.8562,
'std': 59.7999
},
't2s': {
'size': (96, 96, 48),
'mean': 87.0212,
'std': 64.425
},
't1': {
'size': (64, 64, 48),
'mean': 88.5001,
'std': 66.275
}
}
# load 3d model
seg_model = load_trained_model(model_fname)
im = Image(fname_in)
out = im.copy()
out.data *= 0
out.changeType('uint8')
# segment the spinal cord
sct.log.info(
"Segmenting the spinal cord using deep learning on 3D patches...")
z_patch_size = dct_patch_sc_3d[contrast_type]['size'][2]
z_step_keep = range(0, im.data.shape[2], z_patch_size)
for zz in z_step_keep:
if zz == z_step_keep[
-1]: # deal with instances where the im.data.shape[2] % patch_size_z != 0
patch_im = np.zeros(dct_patch_sc_3d[contrast_type]['size'])
z_patch_extracted = im.data.shape[2] - zz
patch_im[:, :, :z_patch_extracted] = im.data[:, :, zz:]
else:
z_patch_extracted = z_patch_size
patch_im = im.data[:, :, zz:z_patch_size + zz]
if np.sum(
patch_im
): # Check if the patch is (not) empty, which could occur after a brain detection.
patch_norm = _normalize_data(
patch_im, dct_patch_sc_3d[contrast_type]['mean'],
dct_patch_sc_3d[contrast_type]['std'])
patch_pred_proba = seg_model.predict(
np.expand_dims(np.expand_dims(patch_norm, 0), 0))
pred_seg_th = (patch_pred_proba > 0.5).astype(int)[0, 0, :, :, :]
x_cOm, y_cOm = None, None
for zz_pp in range(z_patch_size):
pred_seg_pp = post_processing_slice_wise(
pred_seg_th[:, :, zz_pp], x_cOm, y_cOm)
pred_seg_th[:, :, zz_pp] = pred_seg_pp
x_cOm, y_cOm = center_of_mass(pred_seg_pp)
x_cOm, y_cOm = np.round(x_cOm), np.round(y_cOm)
if zz == z_step_keep[-1]:
out.data[:, :, zz:] = pred_seg_th[:, :, :z_patch_extracted]
else:
out.data[:, :, zz:z_patch_size + zz] = pred_seg_th
out.setFileName(fname_out)
out.save()
del im, out
