def main(model_path, exp_config):
# Make and restore vagan model
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type='latest')
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
ncc_list = []
for ii, batch in enumerate(data.test.iterate_batches(1)):
if ii % 10 == 0:
print('Progress: %d' % ii)
x_b, s_b = batch
s_m, s_v, s_e = segvae_model.predict_mean_variance_and_error_maps(
s_b, x_b, num_samples=100)
ncc_list.append(utils.ncc(s_v, s_e))
ncc_arr = np.asarray(ncc_list)
ncc_mean = np.mean(ncc_arr, axis=0)
ncc_std = np.std(ncc_arr, axis=0)
print('NCC mean: %.4f', ncc_mean)
print('NCC std: %.4f', ncc_std)
def main(model_path, exp_config, do_plots=False):
n_samples = 50
model_selection = 'best_ged'
# Get Data
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type=model_selection)
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
N = data.test.images.shape[0]
ged_list = []
ncc_list = []
for ii in range(N):
if ii % 10 == 0:
logging.info("Progress: %d" % ii)
x_b = data.test.images[ii, ...].reshape([1] + list(exp_config.image_size))
s_b = data.test.labels[ii, ...]
x_b_stacked = np.tile(x_b, [n_samples, 1, 1, 1])
feed_dict = {}
feed_dict[segvae_model.training_pl] = False
feed_dict[segvae_model.x_inp] = x_b_stacked
s_arr_sm = segvae_model.sess.run(segvae_model.s_out_eval_sm, feed_dict=feed_dict)
s_arr = np.argmax(s_arr_sm, axis=-1)
# s_arr = np.squeeze(np.asarray(s_list)) # num samples x X x Y
s_b_r = s_b.transpose((2,0,1)) # num gts x X x Y
s_b_r_sm = utils.convert_batch_to_onehot(s_b_r, exp_config.nlabels) # num gts x X x Y x nlabels
ged = utils.generalised_energy_distance(s_arr, s_b_r, nlabels=exp_config.nlabels-1, label_range=range(1,exp_config.nlabels))
ged_list.append(ged)
ncc = utils.variance_ncc_dist(s_arr_sm, s_b_r_sm)
ncc_list.append(ncc)
ged_arr = np.asarray(ged_list)
ncc_arr = np.asarray(ncc_list)
logging.info('-- GED: --')
logging.info(np.mean(ged_arr))
logging.info(np.std(ged_arr))
logging.info('-- NCC: --')
logging.info(np.mean(ncc_arr))
logging.info(np.std(ncc_arr))
np.savez(os.path.join(model_path, 'ged%s_%s.npz' % (str(n_samples), model_selection)), ged_arr)
np.savez(os.path.join(model_path, 'ncc%s_%s.npz' % (str(n_samples), model_selection)), ncc_arr)
def main(model_path, exp_config):
# Get Data
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
data = data_loader(exp_config)
# Make and restore vagan model
classifier_model = classifier(exp_config=exp_config, data=data, fixed_batch_size=1)
# classifier_model.initialise_saliency(mode='additive_pertubation')
# classifier_model.initialise_saliency(mode='backprop')
# classifier_model.initialise_saliency(mode='integrated_gradients')
classifier_model.initialise_saliency(mode='guided_backprop')
# classifier_model.initialise_saliency(mode='CAM') # Requires CAM net (obvs)
classifier_model.load_weights(model_path, type='best_xent')
for batch in data.testAD.iterate_batches(1):
x, y = batch
sal = classifier_model.compute_saliency(x, label=1)
plt.figure()
plt.imshow(np.squeeze(x))
plt.figure()
plt.imshow(np.squeeze(sal))
plt.show()
def calculate_expert_diversity(exp_config):
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
diversity = []
for ii in tqdm(range(data.test.images.shape[0])):
targets = data.test.labels[ii, ...].transpose((2, 0, 1))
ged_, diversity_ = utils.generalised_energy_distance(targets, targets, exp_config.nlabels - 1,
range(1, exp_config.nlabels))
diversity.append(diversity_)
diversity = np.array(diversity)
print(f'{np.mean(diversity):.6f} +- {nanstderr(diversity):.6f}')
def main(exp_config):
logging.info(
'**************************************************************')
logging.info(' *** Running Experiment: %s', exp_config.experiment_name)
logging.info(
'**************************************************************')
# Get Data
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Create Model
phiseg = phiseg_model.phiseg(exp_config)
# Fit model to data
phiseg.train(data)
def main():
# Select experiment below
# from classifier.experiments import synthetic_CAM as exp_config
# from classifier.experiments import synthetic_vgg16 as exp_config
from classifier.experiments import synthetic_resnet34 as exp_config
# Get Data
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Build VAGAN model
classifier_model = classifier(exp_config=exp_config, data=data, fixed_batch_size=exp_config.batch_size)
# Train VAGAN model
classifier_model.train()
def main():
# Select experiment below
# from detseg.experiments import acdc_unet as exp_config
from detseg.experiments import acdc_probunetarch as exp_config
# from detseg.experiments import lidc_probunetarch as exp_config
# from detseg.experiments import uzh_prostate_probunetarch as exp_config
# from detseg.experiments import twolbl_uzh_prostate_probunetarch as exp_config
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Build VAGAN model
segmenter_model = segmenter(exp_config=exp_config,
data=data,
fixed_batch_size=exp_config.batch_size)
# Train VAGAN model
segmenter_model.train()
def main():
# Select experiment below
# from segmenter.experiments import synthetic_unet as exp_config
# from segmenter.experiments import acdc_resunet as exp_config
# from segmenter.experiments import acdc_unet3D as exp_config
from segmenter.experiments import acdc_unet as exp_config
# from segmenter.experiments import nci_prostate_unet as exp_config
# from segmenter.experiments import nci_prostate_unet3D as exp_config
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Build VAGAN model
segmenter_model = segmenter(exp_config=exp_config,
data=data,
fixed_batch_size=exp_config.batch_size)
# Train VAGAN model
segmenter_model.train()
def main(model_path, exp_config):
# Make and restore vagan model
phiseg_model = phiseg(exp_config=exp_config)
phiseg_model.load_weights(model_path, type=model_selection)
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
N = data.test.images.shape[0]
n_images = 16
n_samples = 16
# indices = np.arange(N)
# sample_inds = np.random.choice(indices, n_images)
sample_inds = [165, 280, 213] # <-- prostate
# sample_inds = [1551] #[907, 1296, 1551] # <-- LIDC
for ii in sample_inds:
print('------- Processing image %d -------' % ii)
outfolder = os.path.join(model_path, 'samples_%s' % model_selection,
str(ii))
utils.makefolder(outfolder)
x_b = data.test.images[ii,
...].reshape([1] + list(exp_config.image_size))
s_b = data.test.labels[ii, ...]
if np.sum(s_b) < 10:
print('WARNING: skipping cases with no structures')
continue
s_b_r = utils.convert_batch_to_onehot(s_b.transpose((2, 0, 1)),
exp_config.nlabels)
print('Plotting input image')
plt.figure()
x_b_d = preproc_image(x_b)
plt.imshow(x_b_d, cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'input_img_%d.png' % ii),
bbox_inches='tight')
print('Generating 100 samples')
s_p_list = []
for kk in range(100):
s_p_list.append(
phiseg_model.predict_segmentation_sample(x_b,
return_softmax=True))
s_p_arr = np.squeeze(np.asarray(s_p_list))
print('Plotting %d of those samples' % n_samples)
for jj in range(n_samples):
s_p_sm = s_p_arr[jj, ...]
s_p_am = np.argmax(s_p_sm, axis=-1)
plt.figure()
s_p_d = preproc_image(s_p_am, nlabels=exp_config.nlabels)
plt.imshow(s_p_d, cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder,
'sample_img_%d_samp_%d.png' % (ii, jj)),
bbox_inches='tight')
print('Plotting ground-truths masks')
for jj in range(s_b_r.shape[0]):
s_b_sm = s_b_r[jj, ...]
s_b_am = np.argmax(s_b_sm, axis=-1)
plt.figure()
s_p_d = preproc_image(s_b_am, nlabels=exp_config.nlabels)
plt.imshow(s_p_d, cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder,
'gt_img_%d_samp_%d.png' % (ii, jj)),
bbox_inches='tight')
print('Generating error masks')
E_ss, E_sy_avg, E_yy_avg = generate_error_maps(s_p_arr, s_b_r)
print('Plotting them')
plt.figure()
plt.imshow(preproc_image(E_ss))
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'E_ss_%d.png' % ii),
bbox_inches='tight')
print('Plotting them')
plt.figure()
plt.imshow(preproc_image(np.log(E_ss)))
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'log_E_ss_%d.png' % ii),
bbox_inches='tight')
plt.figure()
plt.imshow(preproc_image(E_sy_avg))
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'E_sy_avg_%d_.png' % ii),
bbox_inches='tight')
plt.figure()
plt.imshow(preproc_image(E_yy_avg))
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'E_yy_avg_%d_.png' % ii),
bbox_inches='tight')
plt.close('all')
def main(model_path, exp_config):
# Make and restore vagan model
phiseg_model = phiseg(exp_config=exp_config)
phiseg_model.load_weights(model_path, type='best_ged')
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
lat_lvls = exp_config.latent_levels
# RANDOM IMAGE
# x_b, s_b = data.test.next_batch(1)
# FIXED IMAGE
# Cardiac: 100 normal image
# LIDC: 200 large lesion, 203, 1757 complicated lesion
# Prostate: 165 nice slice, 170 is a challenging and interesting slice
index = 165 # #
if SAVE_GIF:
outfolder_gif = os.path.join(model_path,
'model_samples_id%d_gif' % index)
utils.makefolder(outfolder_gif)
x_b = data.test.images[index,
...].reshape([1] + list(exp_config.image_size))
x_b_d = utils.convert_to_uint8(np.squeeze(x_b))
x_b_d = utils.resize_image(x_b_d, video_target_size)
if exp_config.data_identifier == 'uzh_prostate':
# rotate
rows, cols = x_b_d.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 270, 1)
x_b_d = cv2.warpAffine(x_b_d, M, (cols, rows))
if SAVE_VIDEO:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
outfile = os.path.join(model_path, 'model_samples_id%d.avi' % index)
out = cv2.VideoWriter(outfile, fourcc, 5.0,
(2 * video_target_size[1], video_target_size[0]))
samps = 20
for ii in range(samps):
# fix all below current level (the correct implementation)
feed_dict = {}
feed_dict[phiseg_model.training_pl] = False
feed_dict[phiseg_model.x_inp] = x_b
s_p, s_p_list = phiseg_model.sess.run(
[phiseg_model.s_out_eval, phiseg_model.s_out_eval_list],
feed_dict=feed_dict)
s_p = np.argmax(s_p, axis=-1)
# s_p_d = utils.convert_to_uint8(np.squeeze(s_p))
s_p_d = np.squeeze(np.uint8((s_p / exp_config.nlabels) * 255))
s_p_d = utils.resize_image(s_p_d,
video_target_size,
interp=cv2.INTER_NEAREST)
if exp_config.data_identifier == 'uzh_prostate':
#rotate
s_p_d = cv2.warpAffine(s_p_d, M, (cols, rows))
img = np.concatenate([x_b_d, s_p_d], axis=1)
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = histogram_equalization(img)
if exp_config.data_identifier == 'acdc':
# labels (0 85 170 255)
rv = cv2.inRange(s_p_d, 84, 86)
my = cv2.inRange(s_p_d, 169, 171)
rv_cnt, hierarchy = cv2.findContours(rv, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
my_cnt, hierarchy = cv2.findContours(my, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, rv_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, my_cnt, -1, (0, 0, 255), 1)
if exp_config.data_identifier == 'uzh_prostate':
print(np.unique(s_p_d))
s1 = cv2.inRange(s_p_d, 84, 86)
s2 = cv2.inRange(s_p_d, 169, 171)
# s3 = cv2.inRange(s_p_d, 190, 192)
s1_cnt, hierarchy = cv2.findContours(s1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
s2_cnt, hierarchy = cv2.findContours(s2, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# s3_cnt, hierarchy = cv2.findContours(s3, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, s1_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, s2_cnt, -1, (0, 0, 255), 1)
# cv2.drawContours(img, s3_cnt, -1, (255, 0, 255), 1)
elif exp_config.data_identifier == 'lidc':
thresh = cv2.inRange(s_p_d, 127, 255)
lesion, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, lesion, -1, (0, 255, 0), 1)
if SAVE_VIDEO:
out.write(img)
if SAVE_GIF:
outfile_gif = os.path.join(outfolder_gif,
'frame_%s.png' % str(ii).zfill(3))
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# scipy.misc.imsave(outfile_gif, img_rgb)
im = Image.fromarray(img_rgb)
im = im.resize((im.size[0] * 2, im.size[1] * 2), Image.ANTIALIAS)
im.save(outfile_gif)
if DISPLAY_VIDEO:
cv2.imshow('frame', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if SAVE_VIDEO:
out.release()
cv2.destroyAllWindows()
def main(model_path, exp_config, model_selection='latest'):
# Get Data
phiseg_model = phiseg(exp_config=exp_config)
phiseg_model.load_weights(model_path, type=model_selection)
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Run predictions in an endless loop
dice_list = []
num_samples = 1 if exp_config.likelihood is likelihoods.det_unet2D else 100
for ii, batch in enumerate(data.test.iterate_batches(1)):
if ii % 10 == 0:
logging.info("Progress: %d" % ii)
# print(ii)
x, y = batch
y_ = np.squeeze(phiseg_model.predict(x, num_samples=num_samples))
per_lbl_dice = []
per_pixel_preds = []
per_pixel_gts = []
for lbl in range(exp_config.nlabels):
binary_pred = (y_ == lbl) * 1
binary_gt = (y == lbl) * 1
if np.sum(binary_gt) == 0 and np.sum(binary_pred) == 0:
per_lbl_dice.append(1)
elif np.sum(binary_pred) > 0 and np.sum(binary_gt) == 0 or np.sum(
binary_pred) == 0 and np.sum(binary_gt) > 0:
logging.warning(
'Structure missing in either GT (x)or prediction. ASSD and HD will not be accurate.'
)
per_lbl_dice.append(0)
else:
per_lbl_dice.append(dc(binary_pred, binary_gt))
dice_list.append(per_lbl_dice)
per_pixel_preds.append(y_.flatten())
per_pixel_gts.append(y.flatten())
dice_arr = np.asarray(dice_list)
mean_per_lbl_dice = dice_arr.mean(axis=0)
logging.info('Dice')
logging.info(mean_per_lbl_dice)
logging.info(np.mean(mean_per_lbl_dice))
logging.info('foreground mean: %f' % (np.mean(mean_per_lbl_dice[1:])))
np.savez(os.path.join(model_path, 'dice_%s.npz' % model_selection),
dice_arr)
def main(model_path, exp_config, do_plots=False):
# Get Data
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type=model_selection)
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Run predictions in an endless loop
dice_list = []
num_samples = 1 if exp_config.likelihood is likelihoods.det_unet2D else 100
for ii, batch in enumerate(data.test.iterate_batches(1)):
if ii % 10 == 0:
logging.info("Progress: %d" % ii)
# print(ii)
x, y = batch
# Adding motion corrpution
# x = utils.add_motion_artefacts(np.squeeze(x), 15)
# x = x.reshape([1] + list(exp_config.image_size))
# Add box corruption
# x[:, 192 // 2 - 20:192 // 2 + 20, 192 // 2 - 5:192 // 2 + 5, :] = 0
y_ = np.squeeze(segvae_model.predict(x, num_samples=num_samples))
per_lbl_dice = []
per_pixel_preds = []
per_pixel_gts = []
if do_plots and not sys_config.running_on_gpu_host:
fig = plt.figure()
fig.add_subplot(131)
plt.imshow(np.squeeze(x), cmap='gray')
fig.add_subplot(132)
plt.imshow(np.squeeze(y_))
fig.add_subplot(133)
plt.imshow(np.squeeze(y))
plt.show()
for lbl in range(exp_config.nlabels):
binary_pred = (y_ == lbl) * 1
binary_gt = (y == lbl) * 1
if np.sum(binary_gt) == 0 and np.sum(binary_pred) == 0:
per_lbl_dice.append(1)
elif np.sum(binary_pred) > 0 and np.sum(binary_gt) == 0 or np.sum(
binary_pred) == 0 and np.sum(binary_gt) > 0:
logging.warning(
'Structure missing in either GT (x)or prediction. ASSD and HD will not be accurate.'
)
per_lbl_dice.append(0)
else:
per_lbl_dice.append(dc(binary_pred, binary_gt))
dice_list.append(per_lbl_dice)
per_pixel_preds.append(y_.flatten())
per_pixel_gts.append(y.flatten())
dice_arr = np.asarray(dice_list)
mean_per_lbl_dice = dice_arr.mean(axis=0)
logging.info('Dice')
logging.info(mean_per_lbl_dice)
logging.info(np.mean(mean_per_lbl_dice))
logging.info('foreground mean: %f' % (np.mean(mean_per_lbl_dice[1:])))
np.savez(os.path.join(model_path, 'dice_%s.npz' % model_selection),
dice_arr)
def test(model_path, exp_config, model_selection='latest', num_samples=100, overwrite=False, mode=False):
output_path = get_output_path(model_path, num_samples, model_selection, mode) + '.pickle'
if os.path.exists(output_path) and not overwrite:
return
image_saver = ImageSaver(os.path.join(model_path, 'samples'))
tf.reset_default_graph()
phiseg_model = phiseg(exp_config=exp_config)
phiseg_model.load_weights(model_path, type=model_selection)
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
metrics = {key: [] for key in
['dsc', 'presence', 'ged', 'ncc', 'entropy', 'diversity', 'sample_dsc', 'ece', 'unweighted_ece',
'loglikelihood']}
num_samples = 1 if exp_config.likelihood is likelihoods.det_unet2D else num_samples
for ii in tqdm(range(data.test.images.shape[0])):
image = data.test.images[ii, ...].reshape([1] + list(exp_config.image_size))
targets = data.test.labels[ii, ...].transpose((2, 0, 1))
feed_dict = {phiseg_model.training_pl: False,
phiseg_model.x_inp: np.tile(image, [num_samples, 1, 1, 1])}
prob_maps = phiseg_model.sess.run(phiseg_model.s_out_eval_sm, feed_dict=feed_dict)
samples = np.argmax(prob_maps, axis=-1)
probability = np.mean(prob_maps, axis=0) + 1e-10
metrics['entropy'].append(float(np.sum(-probability * np.log(probability))))
if mode:
prediction = np.round(np.mean(np.argmax(prob_maps, axis=-1), axis=0)).astype(np.int64)
else:
if 'proposed' not in exp_config.experiment_name:
prediction = np.argmax(np.sum(prob_maps, axis=0), axis=-1)
else:
mean = phiseg_model.sess.run(phiseg_model.dist_eval.loc, feed_dict=feed_dict)[0]
mean = np.reshape(mean, image.shape[:-1] + (2,))
prediction = np.argmax(mean, axis=-1)
metrics['loglikelihood'].append(calculate_log_likelihood(targets, prob_maps))
# calculate DSC per expert
metrics['dsc'].append(
[[calc_dsc(target == i, prediction == i) for i in range(exp_config.nlabels)] for target in targets])
metrics['presence'].append([[np.any(target == i) for i in range(exp_config.nlabels)] for target in targets])
metrics['sample_dsc'].append([[[calc_dsc(target == i, sample == i) for i in range(exp_config.nlabels)]
for target in targets] for sample in samples])
# ged and diversity
ged_, diversity_ = utils.generalised_energy_distance(samples, targets, exp_config.nlabels - 1,
range(1, exp_config.nlabels))
metrics['ged'].append(ged_)
metrics['diversity'].append(diversity_)
# NCC
targets_one_hot = utils.to_one_hot(targets, exp_config.nlabels)
metrics['ncc'].append(utils.variance_ncc_dist(prob_maps, targets_one_hot)[0])
prob_map = np.mean(prob_maps, axis=0)
ece, unweighted_ece = calc_class_wise_expected_calibration_error(targets, prob_map, 2, 10)
metrics['ece'].append(ece)
metrics['unweighted_ece'].append(unweighted_ece)
image_saver(str(ii) + '/', image[0, ..., 0], targets, prediction, samples)
metrics = {key: np.array(metric) for key, metric in metrics.items()}
with open(output_path, 'wb') as f:
pickle.dump(metrics, f)
image_saver.close()
def main(model_path, exp_config):
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# RANDOM IMAGE
# x_b, s_b = data.test.next_batch(1)
# FIXED IMAGE
# Cardiac: 100 normal image
# LIDC: 200 large lesion, 203, 1757 complicated lesion
# Prostate: 165 nice slice
index = 165 #
x_b = data.test.images[index,
...].reshape([1] + list(exp_config.image_size))
s_b = data.test.labels[index, ...]
annot_index_gen = cycle(exp_config.annotator_range)
x_b_d = utils.convert_to_uint8(np.squeeze(x_b))
x_b_d = utils.resize_image(x_b_d, video_target_size)
if SAVE_VIDEO:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
outfile = os.path.join(model_path, 'gt_samples_id%d.avi' % index)
out = cv2.VideoWriter(outfile, fourcc, 5.0,
(2 * video_target_size[1], video_target_size[0]))
for _ in range(50):
annot_index = next(annot_index_gen)
s_b_d = s_b[..., annot_index]
s_b_d = np.squeeze(np.uint8((s_b_d / exp_config.nlabels) * 255))
s_b_d = utils.resize_image(s_b_d,
video_target_size,
interp=cv2.INTER_NEAREST)
img = np.concatenate([x_b_d, s_b_d], axis=1)
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = histogram_equalization(img)
if exp_config.data_identifier == 'acdc':
# labels (0 85 170 255)
rv = cv2.inRange(s_b_d, 84, 86)
my = cv2.inRange(s_b_d, 169, 171)
rv_cnt, hierarchy = cv2.findContours(rv, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
my_cnt, hierarchy = cv2.findContours(my, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, rv_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, my_cnt, -1, (0, 0, 255), 1)
if exp_config.data_identifier == 'uzh_prostate':
# labels (0 85 170 255)
print(np.unique(s_b_d))
s1 = cv2.inRange(s_b_d, 84, 86)
s2 = cv2.inRange(s_b_d, 169, 171)
# s3 = cv2.inRange(s_p_d, 190, 192)
s1_cnt, hierarchy = cv2.findContours(s1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
s2_cnt, hierarchy = cv2.findContours(s2, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# s3_cnt, hierarchy = cv2.findContours(s3, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, s1_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, s2_cnt, -1, (0, 0, 255), 1)
# cv2.drawContours(img, s3_cnt, -1, (255, 0, 255), 1)
elif exp_config.data_identifier == 'lidc':
thresh = cv2.inRange(s_b_d, 127, 255)
lesion, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, lesion, -1, (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(
img, 'Expert # %d/%d' %
(annot_index + 1, len(exp_config.annotator_range)), (30, 256 - 30),
font, 1, (255, 255, 255), 1, cv2.LINE_AA)
if SAVE_VIDEO:
out.write(img)
cv2.imshow('frame', img)
if cv2.waitKey(200) & 0xFF == ord('q'):
break
if SAVE_VIDEO:
out.release()
cv2.destroyAllWindows()
def main(input_folder,
output_folder,
model_path,
exp_config,
do_postprocessing=False,
gt_exists=True):
# Get Data
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Make and restore vagan model
segmenter_model = segmenter(
exp_config=exp_config, data=data,
fixed_batch_size=1) # CRF model requires fixed batch size
segmenter_model.load_weights(model_path, type='best_dice')
total_time = 0
total_volumes = 0
dice_list = []
assd_list = []
hd_list = []
for folder in os.listdir(input_folder):
folder_path = os.path.join(input_folder, folder)
if os.path.isdir(folder_path):
infos = {}
for line in open(os.path.join(folder_path, 'Info.cfg')):
label, value = line.split(':')
infos[label] = value.rstrip('\n').lstrip(' ')
patient_id = folder.lstrip('patient')
if not int(patient_id) % 5 == 0:
continue
ED_frame = int(infos['ED'])
ES_frame = int(infos['ES'])
for file in glob.glob(
os.path.join(folder_path, 'patient???_frame??.nii.gz')):
logging.info(' ----- Doing image: -------------------------')
logging.info('Doing: %s' % file)
logging.info(' --------------------------------------------')
file_base = file.split('.nii.gz')[0]
frame = int(file_base.split('frame')[-1])
img, img_affine, img_header = utils.load_nii(file)
img = utils.normalise_image(img)
zooms = img_header.get_zooms()
if gt_exists:
file_mask = file_base + '_gt.nii.gz'
mask, mask_affine, mask_header = utils.load_nii(file_mask)
start_time = time.time()
if exp_config.dimensionality_mode == '2D':
pixel_size = (img_header.structarr['pixdim'][1],
img_header.structarr['pixdim'][2])
scale_vector = (pixel_size[0] /
exp_config.target_resolution[0],
pixel_size[1] /
exp_config.target_resolution[1])
predictions = []
nx, ny = exp_config.image_size
for zz in range(img.shape[2]):
slice_img = np.squeeze(img[:, :, zz])
slice_rescaled = transform.rescale(slice_img,
scale_vector,
order=1,
preserve_range=True,
multichannel=False,
mode='constant')
x, y = slice_rescaled.shape
x_s = (x - nx) // 2
y_s = (y - ny) // 2
x_c = (nx - x) // 2
y_c = (ny - y) // 2
# Crop section of image for prediction
if x > nx and y > ny:
slice_cropped = slice_rescaled[x_s:x_s + nx,
y_s:y_s + ny]
else:
slice_cropped = np.zeros((nx, ny))
if x <= nx and y > ny:
slice_cropped[x_c:x_c +
x, :] = slice_rescaled[:,
y_s:y_s +
ny]
elif x > nx and y <= ny:
slice_cropped[:, y_c:y_c +
y] = slice_rescaled[x_s:x_s +
nx, :]
else:
slice_cropped[x_c:x_c + x, y_c:y_c +
y] = slice_rescaled[:, :]
# GET PREDICTION
network_input = np.float32(
np.tile(np.reshape(slice_cropped, (nx, ny, 1)),
(1, 1, 1, 1)))
mask_out, softmax = segmenter_model.predict(
network_input)
prediction_cropped = np.squeeze(softmax[0, ...])
# ASSEMBLE BACK THE SLICES
slice_predictions = np.zeros(
(x, y, exp_config.nlabels))
# insert cropped region into original image again
if x > nx and y > ny:
slice_predictions[x_s:x_s + nx, y_s:y_s +
ny, :] = prediction_cropped
else:
if x <= nx and y > ny:
slice_predictions[:, y_s:y_s +
ny, :] = prediction_cropped[
x_c:x_c + x, :, :]
elif x > nx and y <= ny:
slice_predictions[
x_s:x_s +
nx, :, :] = prediction_cropped[:, y_c:y_c +
y, :]
else:
slice_predictions[:, :, :] = prediction_cropped[
x_c:x_c + x, y_c:y_c + y, :]
# RESCALING ON THE LOGITS
if gt_exists:
prediction = transform.resize(
slice_predictions,
(mask.shape[0], mask.shape[1],
exp_config.nlabels),
order=1,
preserve_range=True,
mode='constant')
else: # This can occasionally lead to wrong volume size, therefore if gt_exists
# we use the gt mask size for resizing.
prediction = transform.rescale(
slice_predictions, (1.0 / scale_vector[0],
1.0 / scale_vector[1], 1),
order=1,
preserve_range=True,
multichannel=False,
mode='constant')
prediction = np.uint8(np.argmax(prediction, axis=-1))
# import matplotlib.pyplot as plt
# fig = plt.Figure()
# for ii in range(3):
# plt.subplot(1, 3, ii + 1)
# plt.imshow(np.squeeze(prediction))
# plt.show()
predictions.append(prediction)
prediction_arr = np.transpose(
np.asarray(predictions, dtype=np.uint8), (1, 2, 0))
elif exp_config.dimensionality_mode == '3D':
nx, ny, nz = exp_config.image_size
pixel_size = (img_header.structarr['pixdim'][1],
img_header.structarr['pixdim'][2],
img_header.structarr['pixdim'][3])
scale_vector = (pixel_size[0] /
exp_config.target_resolution[0],
pixel_size[1] /
exp_config.target_resolution[1],
pixel_size[2] /
exp_config.target_resolution[2])
vol_scaled = transform.rescale(img,
scale_vector,
order=1,
preserve_range=True,
multichannel=False,
mode='constant')
nz_max = exp_config.image_size[2]
slice_vol = np.zeros((nx, ny, nz_max), dtype=np.float32)
nz_curr = vol_scaled.shape[2]
stack_from = (nz_max - nz_curr) // 2
stack_counter = stack_from
x, y, z = vol_scaled.shape
x_s = (x - nx) // 2
y_s = (y - ny) // 2
x_c = (nx - x) // 2
y_c = (ny - y) // 2
for zz in range(nz_curr):
slice_rescaled = vol_scaled[:, :, zz]
if x > nx and y > ny:
slice_cropped = slice_rescaled[x_s:x_s + nx,
y_s:y_s + ny]
else:
slice_cropped = np.zeros((nx, ny))
if x <= nx and y > ny:
slice_cropped[x_c:x_c +
x, :] = slice_rescaled[:,
y_s:y_s +
ny]
elif x > nx and y <= ny:
slice_cropped[:, y_c:y_c +
y] = slice_rescaled[x_s:x_s +
nx, :]
else:
slice_cropped[x_c:x_c + x, y_c:y_c +
y] = slice_rescaled[:, :]
slice_vol[:, :, stack_counter] = slice_cropped
stack_counter += 1
stack_to = stack_counter
network_input = np.float32(
np.reshape(slice_vol, (1, nx, ny, nz_max, 1)))
start_time = time.time()
mask_out, softmax = segmenter_model.predict(network_input)
logging.info('Classified 3D: %f secs' %
(time.time() - start_time))
prediction_nzs = mask_out[0, :, :, stack_from:
stack_to] # non-zero-slices
if not prediction_nzs.shape[2] == nz_curr:
raise ValueError('sizes mismatch')
# ASSEMBLE BACK THE SLICES
prediction_scaled = np.zeros(
vol_scaled.shape) # last dim is for logits classes
# insert cropped region into original image again
if x > nx and y > ny:
prediction_scaled[x_s:x_s + nx,
y_s:y_s + ny, :] = prediction_nzs
else:
if x <= nx and y > ny:
prediction_scaled[:, y_s:y_s +
ny, :] = prediction_nzs[x_c:x_c +
x, :, :]
elif x > nx and y <= ny:
prediction_scaled[
x_s:x_s +
nx, :, :] = prediction_nzs[:, y_c:y_c + y, :]
else:
prediction_scaled[:, :, :] = prediction_nzs[
x_c:x_c + x, y_c:y_c + y, :]
logging.info('Prediction_scaled mean %f' %
(np.mean(prediction_scaled)))
prediction = transform.resize(
prediction_scaled,
(mask.shape[0], mask.shape[1], mask.shape[2], 1),
order=1,
preserve_range=True,
mode='constant')
prediction = np.argmax(prediction, axis=-1)
prediction_arr = np.asarray(prediction, dtype=np.uint8)
# This is the same for 2D and 3D again
if do_postprocessing:
prediction_arr = utils.keep_largest_connected_components(
prediction_arr)
elapsed_time = time.time() - start_time
total_time += elapsed_time
total_volumes += 1
logging.info('Evaluation of volume took %f secs.' %
elapsed_time)
if frame == ED_frame:
frame_suffix = '_ED'
elif frame == ES_frame:
frame_suffix = '_ES'
else:
raise ValueError(
'Frame doesnt correspond to ED or ES. frame = %d, ED = %d, ES = %d'
% (frame, ED_frame, ES_frame))
# Save prediced mask
out_file_name = os.path.join(
output_folder, 'prediction',
'patient' + patient_id + frame_suffix + '.nii.gz')
if gt_exists:
out_affine = mask_affine
out_header = mask_header
else:
out_affine = img_affine
out_header = img_header
logging.info('saving to: %s' % out_file_name)
utils.save_nii(out_file_name, prediction_arr, out_affine,
out_header)
# Save image data to the same folder for convenience
image_file_name = os.path.join(
output_folder, 'image',
'patient' + patient_id + frame_suffix + '.nii.gz')
logging.info('saving to: %s' % image_file_name)
utils.save_nii(image_file_name, img, out_affine, out_header)
if gt_exists:
# Save GT image
gt_file_name = os.path.join(
output_folder, 'ground_truth',
'patient' + patient_id + frame_suffix + '.nii.gz')
logging.info('saving to: %s' % gt_file_name)
utils.save_nii(gt_file_name, mask, out_affine, out_header)
# Save difference mask between predictions and ground truth
difference_mask = np.where(
np.abs(prediction_arr - mask) > 0, [1], [0])
difference_mask = np.asarray(difference_mask,
dtype=np.uint8)
diff_file_name = os.path.join(
output_folder, 'difference',
'patient' + patient_id + frame_suffix + '.nii.gz')
logging.info('saving to: %s' % diff_file_name)
utils.save_nii(diff_file_name, difference_mask, out_affine,
out_header)
# calculate metrics
y_ = prediction_arr
y = mask
per_lbl_dice = []
per_lbl_assd = []
per_lbl_hd = []
for lbl in [3, 1, 2]: #range(exp_config.nlabels):
binary_pred = (y_ == lbl) * 1
binary_gt = (y == lbl) * 1
if np.sum(binary_gt) == 0 and np.sum(binary_pred) == 0:
per_lbl_dice.append(1)
per_lbl_assd.append(0)
per_lbl_hd.append(0)
elif np.sum(binary_pred) > 0 and np.sum(
binary_gt) == 0 or np.sum(
binary_pred) == 0 and np.sum(binary_gt) > 0:
logging.warning(
'Structure missing in either GT (x)or prediction. ASSD and HD will not be accurate.'
)
per_lbl_dice.append(0)
per_lbl_assd.append(1)
per_lbl_hd.append(1)
else:
per_lbl_dice.append(dc(binary_pred, binary_gt))
per_lbl_assd.append(
assd(binary_pred, binary_gt, voxelspacing=zooms))
per_lbl_hd.append(
hd(binary_pred, binary_gt, voxelspacing=zooms))
dice_list.append(per_lbl_dice)
assd_list.append(per_lbl_assd)
hd_list.append(per_lbl_hd)
logging.info('Average time per volume: %f' % (total_time / total_volumes))
dice_arr = np.asarray(dice_list)
assd_arr = np.asarray(assd_list)
hd_arr = np.asarray(hd_list)
mean_per_lbl_dice = dice_arr.mean(axis=0)
mean_per_lbl_assd = assd_arr.mean(axis=0)
mean_per_lbl_hd = hd_arr.mean(axis=0)
logging.info('Dice')
logging.info(mean_per_lbl_dice)
logging.info(np.mean(mean_per_lbl_dice))
logging.info('ASSD')
logging.info(mean_per_lbl_assd)
logging.info(np.mean(mean_per_lbl_assd))
logging.info('HD')
logging.info(mean_per_lbl_hd)
logging.info(np.mean(mean_per_lbl_hd))
def main(model_path, exp_config, do_plots=False):
# Get Data
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
# Make and restore vagan model
segmenter_model = segmenter(
exp_config=exp_config, data=data,
fixed_batch_size=1) # CRF model requires fixed batch size
segmenter_model.load_weights(model_path, type='best_dice')
# Run predictions in an endless loop
dice_list = []
assd_list = []
hd_list = []
logging.info('WARNING: Adding motion corruption!')
for ii, batch in enumerate(data.test.iterate_batches(1)):
if ii % 100 == 0:
logging.info("Progress: %d" % ii)
x, y = batch
# Adding motion corrpution
# x = utils.add_motion_artefacts(np.squeeze(x), 15)
# x = x.reshape([1] + list(exp_config.image_size) + [1])
# Add box corruption
# x[:, 192 // 2 - 20:192 // 2 + 20, 192 // 2 - 5:192 // 2 + 5, :] = 0
y_ = segmenter_model.predict(x)[0]
per_lbl_dice = []
per_lbl_assd = []
per_lbl_hd = []
per_pixel_preds = []
per_pixel_gts = []
if do_plots and not sys_config.running_on_gpu_host:
fig = plt.figure()
fig.add_subplot(131)
plt.imshow(np.squeeze(x), cmap='gray')
fig.add_subplot(132)
plt.imshow(np.squeeze(y_))
fig.add_subplot(133)
plt.imshow(np.squeeze(y))
plt.show()
for lbl in range(exp_config.nlabels):
binary_pred = (y_ == lbl) * 1
binary_gt = (y == lbl) * 1
if np.sum(binary_gt) == 0 and np.sum(binary_pred) == 0:
per_lbl_dice.append(1)
# per_lbl_assd.append(0)
# per_lbl_hd.append(0)
elif np.sum(binary_pred) > 0 and np.sum(binary_gt) == 0 or np.sum(
binary_pred) == 0 and np.sum(binary_gt) > 0:
logging.warning(
'Structure missing in either GT (x)or prediction. ASSD and HD will not be accurate.'
)
per_lbl_dice.append(0)
# per_lbl_assd.append(1)
# per_lbl_hd.append(1)
else:
per_lbl_dice.append(dc(binary_pred, binary_gt))
# per_lbl_assd.append(assd(binary_pred, binary_gt))
# per_lbl_hd.append(hd(binary_pred, binary_gt))
dice_list.append(per_lbl_dice)
assd_list.append(per_lbl_assd)
hd_list.append(per_lbl_hd)
per_pixel_preds.append(y_.flatten())
per_pixel_gts.append(y.flatten())
dice_arr = np.asarray(dice_list)
assd_arr = np.asarray(assd_list)
hd_arr = np.asarray(hd_list)
mean_per_lbl_dice = dice_arr.mean(axis=0)
mean_per_lbl_assd = assd_arr.mean(axis=0)
mean_per_lbl_hd = hd_arr.mean(axis=0)
logging.info('Dice')
logging.info(mean_per_lbl_dice)
logging.info(np.mean(mean_per_lbl_dice))
logging.info('foreground mean: %f' % (np.mean(mean_per_lbl_dice[1:])))
np.savez(os.path.join(model_path, 'dice.npz'), dice_arr)
def main(model_path, exp_config):
# Make and restore vagan model
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type='best_ged')
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
lat_lvls = exp_config.latent_levels
# RANDOM IMAGE
# x_b, s_b = data.test.next_batch(1)
# FIXED IMAGE
# Cardiac: 100 normal image
# LIDC: 200 large lesion, 203, 1757 complicated lesion
# Prostate: 165 nice slice
index = 165 #
x_b = data.test.images[index,
...].reshape([1] + list(exp_config.image_size))
x_b_d = utils.convert_to_uint8(np.squeeze(x_b))
x_b_d = utils.resize_image(x_b_d, video_target_size)
if SAVE_VIDEO:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
outfile = os.path.join(model_path, 'model_samples_id%d.avi' % index)
out = cv2.VideoWriter(outfile, fourcc, 5.0,
(2 * video_target_size[1], video_target_size[0]))
samps = 50
for _ in range(samps):
# fix all below current level (the correct implementation)
feed_dict = {}
feed_dict[segvae_model.training_pl] = False
feed_dict[segvae_model.x_inp] = x_b
s_p, s_p_list = segvae_model.sess.run(
[segvae_model.s_out_eval, segvae_model.s_out_eval_list],
feed_dict=feed_dict)
s_p = np.argmax(s_p, axis=-1)
# s_p_d = utils.convert_to_uint8(np.squeeze(s_p))
s_p_d = np.squeeze(np.uint8((s_p / exp_config.nlabels) * 255))
s_p_d = utils.resize_image(s_p_d,
video_target_size,
interp=cv2.INTER_NEAREST)
img = np.concatenate([x_b_d, s_p_d], axis=1)
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = histogram_equalization(img)
if exp_config.data_identifier == 'acdc':
# labels (0 85 170 255)
rv = cv2.inRange(s_p_d, 84, 86)
my = cv2.inRange(s_p_d, 169, 171)
rv_cnt, hierarchy = cv2.findContours(rv, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
my_cnt, hierarchy = cv2.findContours(my, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, rv_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, my_cnt, -1, (0, 0, 255), 1)
if exp_config.data_identifier == 'uzh_prostate':
# labels (0 85 170 255)
print(np.unique(s_p_d))
s1 = cv2.inRange(s_p_d, 84, 86)
s2 = cv2.inRange(s_p_d, 169, 171)
# s3 = cv2.inRange(s_p_d, 190, 192)
s1_cnt, hierarchy = cv2.findContours(s1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
s2_cnt, hierarchy = cv2.findContours(s2, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# s3_cnt, hierarchy = cv2.findContours(s3, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, s1_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, s2_cnt, -1, (0, 0, 255), 1)
# cv2.drawContours(img, s3_cnt, -1, (255, 0, 255), 1)
elif exp_config.data_identifier == 'lidc':
thresh = cv2.inRange(s_p_d, 127, 255)
lesion, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, lesion, -1, (0, 255, 0), 1)
if SAVE_VIDEO:
out.write(img)
cv2.imshow('frame', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if SAVE_VIDEO:
out.release()
cv2.destroyAllWindows()
def main(model_path, exp_config):
# Make and restore vagan model
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type='best_dice')
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
outfolder = '/home/baumgach/Reports/ETH/MICCAI2019_segvae/raw_figures'
ims = exp_config.image_size
# x_b, s_b = data.test.next_batch(1)
# heart 100
# prostate 165
index = 165 # 100 is a normal image, 15 is a very good slice
x_b = data.test.images[index,
...].reshape([1] + list(exp_config.image_size))
if exp_config.data_identifier == 'lidc':
s_b = data.test.labels[index, ...]
if np.sum(s_b[..., 0]) > 0:
s_b = s_b[..., 0]
elif np.sum(s_b[..., 1]) > 0:
s_b = s_b[..., 1]
elif np.sum(s_b[..., 2]) > 0:
s_b = s_b[..., 2]
else:
s_b = s_b[..., 3]
s_b = s_b.reshape([1] + list(exp_config.image_size[0:2]))
elif exp_config.data_identifier == 'uzh_prostate':
s_b = data.test.labels[index, ...]
s_b = s_b[..., 0]
s_b = s_b.reshape([1] + list(exp_config.image_size[0:2]))
else:
s_b = data.test.labels[index,
...].reshape([1] +
list(exp_config.image_size[0:2]))
x_b_for_cnt = utils.convert_to_uint8(np.squeeze(x_b.copy()))
x_b_for_cnt = cv2.cvtColor(x_b_for_cnt, cv2.COLOR_GRAY2BGR)
x_b_for_cnt = utils.resize_image(x_b_for_cnt, (2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
x_b_for_cnt = utils.histogram_equalization(x_b_for_cnt)
for ss in range(3):
print(ss)
s_p_list = segvae_model.predict_segmentation_sample_levels(
x_b, return_softmax=False)
accum_list = [None] * exp_config.latent_levels
accum_list[exp_config.latent_levels - 1] = s_p_list[-1]
for lvl in reversed(range(exp_config.latent_levels - 1)):
accum_list[lvl] = accum_list[lvl + 1] + s_p_list[lvl]
print('Plotting accum_list')
for ii, img in enumerate(accum_list):
plt.figure()
img = utils.resize_image(np.squeeze(np.argmax(img, axis=-1)),
(2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
plt.imshow(img[2 * 30:2 * 192 - 2 * 30, 2 * 30:2 * 192 - 2 * 30],
cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder,
'segm_lvl_%d_samp_%d.png' % (ii, ss)),
bbox_inches='tight')
print('Plotting s_p_list')
for ii, img in enumerate(s_p_list):
img = utils.softmax(img)
plt.figure()
img = utils.resize_image(np.squeeze(img[..., 1]),
(2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
plt.imshow(img[2 * 30:2 * 192 - 2 * 30, 2 * 30:2 * 192 - 2 * 30],
cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder,
'residual_lvl_%d_samp_%d.png' % (ii, ss)),
bbox_inches='tight')
s_p_d = np.uint8((np.squeeze(np.argmax(accum_list[0], axis=-1)) /
(exp_config.nlabels - 1)) * 255)
s_p_d = utils.resize_image(s_p_d, (2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
print('Calculating contours')
print(np.unique(s_p_d))
rv = cv2.inRange(s_p_d, 84, 86)
my = cv2.inRange(s_p_d, 169, 171)
rv_cnt, hierarchy = cv2.findContours(rv, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
my_cnt, hierarchy = cv2.findContours(my, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
x_b_for_cnt = cv2.drawContours(x_b_for_cnt, rv_cnt, -1, (0, 255, 0), 1)
x_b_for_cnt = cv2.drawContours(x_b_for_cnt, my_cnt, -1, (0, 0, 255), 1)
x_b_for_cnt = cv2.cvtColor(x_b_for_cnt, cv2.COLOR_BGR2RGB)
print('Plotting final images...')
plt.figure()
plt.imshow(x_b_for_cnt[2 * 30:2 * 192 - 2 * 30,
2 * 30:2 * 192 - 2 * 30, :],
cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'input_img_cnts.png'),
bbox_inches='tight')
plt.figure()
x_b = utils.convert_to_uint8(x_b)
x_b = cv2.cvtColor(np.squeeze(x_b), cv2.COLOR_GRAY2BGR)
x_b = utils.histogram_equalization(x_b)
x_b = utils.resize_image(x_b, (2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
plt.imshow(x_b[2 * 30:2 * 192 - 2 * 30, 2 * 30:2 * 192 - 2 * 30],
cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'input_img.png'), bbox_inches='tight')
plt.figure()
s_b = utils.resize_image(np.squeeze(s_b), (2 * ims[0], 2 * ims[1]),
interp=cv2.INTER_NEAREST)
plt.imshow(s_b[2 * 30:2 * 192 - 2 * 30, 2 * 30:2 * 192 - 2 * 30],
cmap='gray')
plt.axis('off')
plt.savefig(os.path.join(outfolder, 'gt_seg.png'), bbox_inches='tight')
def main(model_path, exp_config):
# Make and restore vagan model
segvae_model = segvae(exp_config=exp_config)
segvae_model.load_weights(model_path, type='best_ged')
data_loader = data_switch(exp_config.data_identifier)
data = data_loader(exp_config)
lat_lvls = exp_config.latent_levels
# RANDOM IMAGE
# x_b, s_b = data.test.next_batch(1)
# FIXED IMAGE
# Cardiac: 100 normal image
# LIDC: 200 large lesion, 203, 1757 complicated lesion
# Prostate: 165 nice slice
index = 165 #
x_b = data.test.images[index,
...].reshape([1] + list(exp_config.image_size))
if exp_config.data_identifier == 'lidc':
s_b = data.test.labels[index, ...]
if np.sum(s_b[..., 0]) > 0:
s_b = s_b[..., 0]
elif np.sum(s_b[..., 1]) > 0:
s_b = s_b[..., 1]
elif np.sum(s_b[..., 2]) > 0:
s_b = s_b[..., 2]
else:
s_b = s_b[..., 3]
s_b = s_b.reshape([1] + list(exp_config.image_size[0:2]))
elif exp_config.data_identifier == 'uzh_prostate':
s_b = data.test.labels[index, ...]
s_b = s_b[..., 0]
s_b = s_b.reshape([1] + list(exp_config.image_size[0:2]))
else:
s_b = data.test.labels[index,
...].reshape([1] +
list(exp_config.image_size[0:2]))
#
# print(x_b.shape)
# print(s_b.shape)
# x_b[:,30:64+10,64:64+10,:] = np.mean(x_b)
#
# x_b = utils.add_motion_artefacts(np.squeeze(x_b), 15)
# x_b = x_b.reshape([1]+list(exp_config.image_size))
x_b_d = utils.convert_to_uint8(np.squeeze(x_b))
x_b_d = utils.resize_image(x_b_d, video_target_size)
s_b_d = np.squeeze(np.uint8((s_b / exp_config.nlabels) * 255))
s_b_d = utils.resize_image(s_b_d,
video_target_size,
interp=cv2.INTER_NEAREST)
_, mu_list_init, _ = segvae_model.generate_prior_samples(
x_b, return_params=True)
if SAVE_VIDEO:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
outfile = os.path.join(model_path, 'samplevid_id%d.avi' % index)
out = cv2.VideoWriter(outfile, fourcc, 10.0,
(3 * video_target_size[1], video_target_size[0]))
for lvl in reversed(range(lat_lvls)):
samps = 50 if lat_lvls > 1 else 200
for _ in range(samps):
# z_list, mu_list, sigma_list = segvae_model.generate_prior_samples(x_b, return_params=True)
print('doing level %d/%d' % (lvl, lat_lvls))
# fix all below current level
# for jj in range(lvl,lat_lvls-1):
# z_list[jj+1] = mu_list_init[jj+1] # fix jj's level to mu
# sample only current level
# z_list_new = z_list.copy()
# for jj in range(lat_lvls):
# z_list_new[jj] = mu_list_init[jj]
# z_list_new[lvl] = z_list[lvl]
# z_list = z_list_new
#
# print('z means')
# for jj, z in enumerate(z_list):
# print('lvl %d: %.3f' % (jj, np.mean(z)))
#
#
# feed_dict = {i: d for i, d in zip(segvae_model.prior_z_list_gen, z_list)}
# feed_dict[segvae_model.training_pl] = False
#
# fix all below current level (the correct implementation)
feed_dict = {}
for jj in range(lvl, lat_lvls - 1):
feed_dict[segvae_model.prior_z_list_gen[jj +
1]] = mu_list_init[jj +
1]
feed_dict[segvae_model.training_pl] = False
feed_dict[segvae_model.x_inp] = x_b
s_p, s_p_list = segvae_model.sess.run(
[segvae_model.s_out_eval, segvae_model.s_out_eval_list],
feed_dict=feed_dict)
s_p = np.argmax(s_p, axis=-1)
print(np.unique(s_p))
# print('mean logits for myo cardium per level')
# fig = plt.figure()
#
# cumsum = np.zeros((128,128))
# cumsum_all = np.zeros((128,128,4))
# for i, s in enumerate(reversed(s_p_list)):
#
# cumsum += s[0,:,:,2]
# cumsum_all += s[0,:,:,:]
#
# fig.add_subplot(4,4,i+1)
# plt.imshow(s[0,:,:,2])
#
# fig.add_subplot(4,4,i+1+4)
# plt.imshow(cumsum)
#
# fig.add_subplot(4,4,i+1+8)
# plt.imshow(1./(1+np.exp(-cumsum)))
#
# fig.add_subplot(4,4,i+1+12)
# plt.imshow(np.argmax(cumsum_all, axis=-1))
#
#
# plt.show()
# DEUBG
# cum_img = np.squeeze(s_p_list[lat_lvls-1])
# cum_img_disp = softmax(cum_img)
#
# indiv_img = np.squeeze(s_p_list[lat_lvls-1])
# indiv_img_disp = softmax(indiv_img)
#
# for ii in reversed(range(lat_lvls-1)):
# cum_img += np.squeeze(s_p_list[ii])
# indiv_img = np.squeeze(s_p_list[ii])
#
# cum_img_disp = np.concatenate([cum_img_disp, softmax(cum_img)], axis=1)
# indiv_img_disp = np.concatenate([indiv_img_disp, softmax(indiv_img)], axis=1)
#
#
# cum_img_disp = utils.convert_to_uint8(np.argmax(cum_img_disp, axis=-1))
# indiv_img_disp = utils.convert_to_uint8(indiv_img_disp[:,:,2])
#
# cum_img_disp = np.concatenate([cum_img_disp, indiv_img_disp], axis=0)
#
#
# print('cum img shape')
# print(cum_img_disp.shape)
# cv2.imshow('debug', cum_img_disp)
# END DEBUG
# s_p_d = utils.convert_to_uint8(np.squeeze(s_p))
s_p_d = np.squeeze(np.uint8((s_p / exp_config.nlabels) * 255))
s_p_d = utils.resize_image(s_p_d,
video_target_size,
interp=cv2.INTER_NEAREST)
img = np.concatenate([x_b_d, s_b_d, s_p_d], axis=1)
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = histogram_equalization(img)
if exp_config.data_identifier == 'acdc':
# labels (0 85 170 255)
rv = cv2.inRange(s_p_d, 84, 86)
my = cv2.inRange(s_p_d, 169, 171)
rv_cnt, hierarchy = cv2.findContours(rv, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
my_cnt, hierarchy = cv2.findContours(my, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, rv_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, my_cnt, -1, (0, 0, 255), 1)
if exp_config.data_identifier == 'uzh_prostate':
# labels (0 85 170 255)
print(np.unique(s_p_d))
s1 = cv2.inRange(s_p_d, 84, 86)
s2 = cv2.inRange(s_p_d, 169, 171)
# s3 = cv2.inRange(s_p_d, 190, 192)
s1_cnt, hierarchy = cv2.findContours(s1, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
s2_cnt, hierarchy = cv2.findContours(s2, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# s3_cnt, hierarchy = cv2.findContours(s3, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, s1_cnt, -1, (0, 255, 0), 1)
cv2.drawContours(img, s2_cnt, -1, (0, 0, 255), 1)
# cv2.drawContours(img, s3_cnt, -1, (255, 0, 255), 1)
elif exp_config.data_identifier == 'lidc':
thresh = cv2.inRange(s_p_d, 127, 255)
lesion, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img, lesion, -1, (0, 255, 0), 1)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img, 'Sampling level %d/%d' % (lvl + 1, lat_lvls),
(30, 256 - 30), font, 1, (255, 255, 255), 1,
cv2.LINE_AA)
print('actual size')
print(img.shape)
if SAVE_VIDEO:
out.write(img)
cv2.imshow('frame', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if SAVE_VIDEO:
out.release()
cv2.destroyAllWindows()
