def extract_and_save_pairs():
datas = lesloc.get_data_struc(reshape=True)
# datas = reshape_struc(datas)
files = []
# datadir = '/home/tomas/Dropbox/Data/medical/dataset/gt/salmaps/vyber/hypo/res_pklz'
datadir = '/home/tomas/Dropbox/Data/medical/dataset/gt/salmaps/res/best'
for (dirpath, dirnames, filenames) in os.walk(datadir):
filenames = [x for x in filenames if x.split('.')[-1] == 'pklz']
for fname in filenames:
files.append(os.path.join(dirpath, fname))
break
for i, (im1_fn, im2_fn, s1, s2) in enumerate(datas):
print 'data # %i/%i ...' % (i + 1, len(datas))
# getting ground-truth data
__, gt_mask1, __ = tools.load_pickle_data(im1_fn)
gt_mask1 = gt_mask1[s1, ...]
gt_mask1, __ = tools.crop_to_bbox(gt_mask1, gt_mask1 > 0)
# gt_mask1 = gt_mask1 == 1
__, gt_mask2, __ = tools.load_pickle_data(im2_fn)
gt_mask2 = gt_mask2[s2, ...]
gt_mask2, __ = tools.crop_to_bbox(gt_mask2, gt_mask2 > 0)
# gt_mask2 = gt_mask2 == 1
# finding corresponding files
fname1 = find_file(im1_fn, s1, files)
fname2 = find_file(im2_fn, s2, files)
# processing
if fname1 is not None and fname2 is not None:
# data1, gt_mask, voxel_size = tools.load_pickle_data(f)
with gzip.open(fname1, 'rb') as f:
fcontent = f.read()
im1, sm1, res1 = pickle.loads(fcontent)
with gzip.open(fname2, 'rb') as f:
fcontent = f.read()
im2, sm2, res2 = pickle.loads(fcontent)
# identify_tumors(res1, res2, gt_mask1, gt_mask2)
pairs = pair_up_tumors(im1, res1, gt_mask1, im2, res2, gt_mask2)
# ukladani na disk
for j, pair in enumerate(pairs):
__, __, pair_type = pair
kw = fname1.split('/')[-1].split('.')[0].split('-')
nmb = kw[0].split('_')[0]
sl1 = kw[-2]
sl2 = fname2.split('/')[-1].split('.')[0].split('-')[-2]
outfn = '/'.join(fname1.split('/')[:-1]) + '/pairs/%s_sl-%s-%s_p-%i_tp-%s.pklz' % (
nmb, sl1, sl2, j, pair_type)
with gzip.open(outfn, 'wb', compresslevel=1) as f:
pickle.dump(pair, f)
def run(im,
mask=None,
save_fig=False,
smoothing=False,
return_all=False,
show=False,
show_now=True,
verbose=True):
"""
im ... grayscale image
"""
show = True # debug show
set_verbose(verbose)
if mask is None:
mask = np.ones_like(im)
else:
im, mask = tools.crop_to_bbox(im, mask)
mean_v = int(im[np.nonzero(mask)].mean())
im = np.where(mask, im, mean_v)
# im = np.where(mask, im, 255)
im_orig = im.copy()
orig_shape = im_orig.shape[:-1]
if smoothing:
im = tools.smoothing(im)
# intensity
use_sigmoid = True
morph_proc = True
# consp_int = conspicuity_intensity(im, mask=mask, int_type='diff', type='hypo', use_sigmoid=use_sigmoid, show=show, show_now=False)
# consp_int = conspicuity_intensity(im, mask=mask, int_type='hist', type='hypo', use_sigmoid=use_sigmoid, show=show, show_now=False)
# consp_int = conspicuity_intensity(im, mask=mask, int_type='glcm', type='hypo', use_sigmoid=use_sigmoid, show=show, show_now=False)
# consp_sliwin = conspicuity_sliding_window(im, mask=mask, pyr_scale=1.5, show=show, show_now=False)
im = img_as_float(im)
# id = conspicuity_intensity(im.copy(), mask=mask, int_type='diff', type='hypo', use_sigmoid=use_sigmoid, show=show, show_now=False)
# plt.show()
# id = conspicuity_calculation(im, sal_type='int_diff', mask=mask, calc_features=False, use_sigmoid=use_sigmoid, morph_proc=morph_proc, show=show, show_now=False)
# id = conspicuity_calculation(im, sal_type='int_hist', mask=mask, calc_features=False, use_sigmoid=use_sigmoid, morph_proc=morph_proc, show=show, show_now=False)
# id = conspicuity_calculation(im, sal_type='int_glcm', mask=mask, calc_features=False, use_sigmoid=use_sigmoid, morph_proc=morph_proc, show=show, show_now=False)
# isw = conspicuity_calculation(im, sal_type='int_sliwin', mask=mask, calc_features=False, use_sigmoid=False, morph_proc=morph_proc, show=show, show_now=False)
# it = conspicuity_calculation(im, sal_type='texture', mask=mask, calc_features=False, use_sigmoid=False, morph_proc=False, show=show, show_now=False)
# circ = conspicuity_calculation(im, sal_type='circloids', mask=mask, calc_features=False, use_sigmoid=False, morph_proc=True, show=show, show_now=False)
blobs = conspicuity_calculation(im,
sal_type='blobs',
mask=mask,
calc_features=False,
use_sigmoid=False,
morph_proc=True,
show=show,
show_now=False)
# TODO: Conspicuity ... ND verze
if show:
plt.show()
def run(image, mask=None, smoothing=False, show=False, show_now=True):
if mask is None:
mask = np.ones_like(image)
im_orig = image.copy()
else:
image, mask = tools.crop_to_bbox(image, mask)
im_orig = image.copy()
mean_v = int(image[np.nonzero(mask)].mean())
image = np.where(mask, image, mean_v)
mask = mask.astype(np.uint8)
if smoothing:
image = tools.smoothing(image)
# defaultne hleda svetle oblasti
image = np.invert(image)
rgb_image = cv2.cvtColor(image, cv2.COLOR_BAYER_GR2RGB).astype(np.float32)
# print 'Calculate saliency map for test image:'
orgb_image = SightSpotUtil.eval_orgb_image(rgb_image)
# start = time.clock()
saliency_map = SightSpotUtil.eval_saliency_map(orgb_image, 1.0, 40.0, 'auto')
# print 'Saliency map extracted in', time.clock() - start, 'sec.'
# start = time.clock()
# heatmap_image = SightSpotUtil.eval_heatmap(saliency_map)
# heatmap_image = np.asarray(heatmap_image)
# heatmap_image.setflags(write=True)
# print 'Heatmap extracted in', time.clock() - start, 'sec.'
saliency_map *= mask
# heatmap_image *= np.dstack((mask, mask, mask))
im_orig *= mask
saliency_map = skiexp.rescale_intensity(saliency_map, out_range=(0, 1))
if show:
if smoothing:
plt.subplot(131), plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(132), plt.imshow(image, 'gray', interpolation='nearest'), plt.title('smoothed')
plt.subplot(133), plt.imshow(saliency_map, 'gray', interpolation='nearest'), plt.title('saliency')
else:
plt.subplot(121), plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(122), plt.imshow(saliency_map, 'gray', interpolation='nearest'), plt.title('saliency')
if show_now:
plt.show()
return im_orig, image, saliency_map
def run(image, mask=None, smoothing=False, show=False, show_now=True):
if mask is None:
mask = np.ones_like(image)
im_orig = image.copy()
else:
image, mask = tools.crop_to_bbox(image, mask)
im_orig = image.copy()
mean_v = int(image[np.nonzero(mask)].mean())
image = np.where(mask, image, mean_v)
mask = mask.astype(np.uint8)
if smoothing:
image = tools.smoothing(image)
rgb_image = cv2.cvtColor(image, cv2.COLOR_BAYER_GR2BGR).astype(np.float32)
imgsize = rgb_image.shape
img_width = imgsize[1]
img_height = imgsize[0]
sm = pySaliencyMap.pySaliencyMap(img_width, img_height)
saliency_map = sm.SMGetSM(rgb_image)
saliency_map *= mask.astype(np.uint8)
im_orig *= mask.astype(np.uint8)
saliency_map = skiexp.rescale_intensity(saliency_map, out_range=(0, 1))
if show:
plt.figure(figsize=(24, 14))
if smoothing:
plt.subplot(131), plt.imshow(
im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(132), plt.imshow(
image, 'gray', interpolation='nearest'), plt.title('smoothed')
plt.subplot(133), plt.imshow(
saliency_map, 'gray',
interpolation='nearest'), plt.title('saliency')
else:
plt.subplot(121), plt.imshow(
im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(122), plt.imshow(
saliency_map, 'gray',
interpolation='nearest'), plt.title('saliency')
if show_now:
plt.show()
return im_orig, image, saliency_map
def run(image,
mask,
pyr_scale,
method,
smooth=True,
show=False,
show_now=True,
save_fig=False):
# fig_dir = '/home/tomas/Dropbox/Work/Dizertace/figures/saliency/%s/' % method
# if save_fig:
# dirs = fig_dir.split('/')
# for i in range(2, len(dirs)):
# subdir = '/'.join(dirs[:i])
# if not os.path.exists(subdir):
# os.mkdir(subdir)
image, mask = tools.crop_to_bbox(image, mask)
if smooth:
image = tools.smoothing(image, sliceId=0)
pyr_keypts = []
# pyr_survs = []
# pyr_titles = []
pyr_imgs = []
pyr_masks = []
for layer_id, (im_pyr, mask_pyr) in enumerate(
zip(tools.pyramid(image, scale=pyr_scale, inter=cv2.INTER_NEAREST),
tools.pyramid(mask, scale=pyr_scale,
inter=cv2.INTER_NEAREST))):
resp = detect_keypoints(im_pyr,
mask_pyr,
method,
layer_id=layer_id,
smooth=smooth,
show=show,
show_now=show_now,
save_fig=save_fig)
pyr_keypts.append(resp)
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
n_layers = len(pyr_imgs)
def process_slice(img_o, mask_o, proc, show=False, show_now=False, t=0.2):
if not mask_o.any():
return np.zeros_like(img_o), None
img_bbox, mask = tools.crop_to_bbox(img_o, mask_o)
# write mean value outside the mask
mean_val = np.mean(img_bbox[np.nonzero(mask)])
img = np.where(mask, img_bbox, mean_val)
# rescale to UINT8
img = skiexp.rescale_intensity(img,
in_range=(50 - 175, 50 + 175),
out_range=np.uint8).astype(np.uint8)
vis = []
img_pipe = img.copy()
seg = None # final segmentation
# saving input and input with liver borders
# vis.append(('input', img_o))
# liver_contours = skimea.find_contours(mask_o, 0.9)
# vis.append(('liver contours', (img_o, liver_contours)))
# smoothing
if 'smo' in proc or 'smoothing' in proc:
img_s = tools.smoothing(img)
img_pipe = img_s.copy()
# img_pipe_o = tools.put_bbox_back(np.zeros_like(img_pipe_o), img_pipe, mask=mask_o)
vis.append(('smoothing', img_s * mask))
# # write mean value outside the mask
# mean_val = np.mean(img_pipe[np.nonzero(mask)])
# img_pipe = np.where(mask, img_pipe, mean_val)
# Equalization
if 'equ' in proc or 'equalization' in proc:
img_h = skiexp.equalize_hist(img_pipe)
img_pipe = img_h.copy()
# img_pipe_o = tools.put_bbox_back(np.zeros_like(img_pipe_o), img_pipe, mask=mask_o)
vis.append(('equalization', img_h * mask))
# canny edge detector
# canny = tools.auto_canny(skiexp.rescale_intensity(img_eq, out_range=np.uint8).astype(np.uint8), sigma=0.1)
# contrast stretch
if 'str' in proc or 'stretch' in proc:
p = (20, 40)
pmin, pmax = np.percentile(img_pipe, p)
img_rescale = skiexp.rescale_intensity(img_pipe, in_range=(pmin, pmax))
img_pipe = img_rescale.copy()
vis.append(('stretch {}'.format(p), img_rescale * mask))
# morphology
if 'clo' in proc or 'closing' in proc:
r = 7
img_morph = skimor.closing(img_pipe, selem=skimor.disk(r))
img_pipe = img_morph.copy()
seg = tools.put_bbox_back(np.zeros(img_o.shape),
img_pipe < t,
mask=mask_o)
vis.append(('closing r=%i' % r, img_morph * mask))
# contours
if 'con' in proc or 'contours' in proc:
contours = skimea.find_contours(img_pipe, t)
vis.append(('contours', (img_bbox, contours)))
# plt.figure()
# plt.subplot(121), plt.imshow(img_morph, 'gray'), plt.colorbar()
# plt.subplot(122), plt.imshow(seg, 'gray'), plt.colorbar()
# plt.show()
if show:
n_rows, n_cols = [1, len(vis)]
plt.figure()
for i, (title, im) in enumerate(vis):
plt.subplot(n_rows, n_cols, i + 1)
if 'contours' in title:
# plt.imshow(vis[0][1], 'gray', interpolation='nearest'), plt.title(title)
plt.imshow(im[0], 'gray',
interpolation='nearest'), plt.title(title)
plt.hold(True)
for n, contour in enumerate(im[1]):
plt.plot(contour[:, 1], contour[:, 0], linewidth=2)
plt.axis('image')
else:
plt.imshow(im, 'gray',
interpolation='nearest'), plt.title(title)
# if 'con' in proc or 'contours' in proc:
# for n, contour in enumerate(contours):
# plt.plot(contour[:, 1], contour[:, 0], linewidth=2)
# plt.axis('image')
if show_now:
plt.show()
return seg, vis
def run(image,
mask,
proc=['smoo', 'equa', 'clos', 'cont'],
pyr_scale=1.5,
min_pyr_size=(30, 30),
show=False,
show_now=False,
save_fig=False,
verbose=True):
# data, mask = tools.crop_to_bbox(data, mask)
pyr_segs = []
vis = []
image, mask = tools.crop_to_bbox(image, mask)
# for i in range(data.shape[0]):
# # print 'Processing slice #%i/%i' % (i + 1, data.shape[0]),
# print tools.get_status_text('\tProcessing slices', iter=i, max_iter=data.shape[0]),
# seg_s, vis_s = process_slice(data[i, :, :], mask[i, :, :], proc=['smo', 'equ', 'clo', 'con'],
# show=show, show_now=show_now)
# segs.append(seg_s)
# vis.append(vis_s)
# # print 'done'
# print tools.get_status_text('\tProcessing slice', iter=-1, max_iter=data.shape[0])
# pyr_scale = 1.5
pyr_imgs = []
pyr_masks = []
for layer_id, (im_pyr, mask_pyr) in enumerate(
zip(
tools.pyramid(image,
scale=pyr_scale,
min_size=min_pyr_size,
inter=cv2.INTER_NEAREST),
tools.pyramid(mask,
scale=pyr_scale,
min_size=min_pyr_size,
inter=cv2.INTER_NEAREST))):
seg_s, vis_s = process_slice(im_pyr,
mask_pyr,
proc=proc,
show=False,
show_now=show_now)
heep = (vis_s[-2][1].max() - vis_s[-2][1]) * mask_pyr
pyr_segs.append(heep)
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
# survival overall
surv_overall = np.zeros(image.shape)
for survs_l in pyr_segs:
surv_overall += cv2.resize(survs_l, image.shape[::-1])
if show:
n_layers = len(pyr_segs)
imgs = [image, surv_overall] + pyr_segs
n_non_layers = len(imgs) - len(pyr_segs)
titles = ['input', 'surv'
] + ['layer #%i' % (i + 1) for i in range(n_layers)]
# to_rgb = [0, 0] + n_layers * [1, ]
cmaps = ['gray', 'jet'] + n_layers * ['jet']
plt.figure()
# for i, (im, tit, cmap, conv) in enumerate(zip(imgs, titles, cmaps, to_rgb)):
for i, (im, tit, cmap) in enumerate(zip(imgs, titles, cmaps)):
plt.subplot(1, n_layers + n_non_layers, i + 1)
plt.imshow(im, cmap, interpolation='nearest')
plt.title(tit)
if show_now:
plt.show()
return surv_overall
def run(image, mask, pyr_scale=1.5, min_pyr_size=(30, 30), show=False, show_now=True, verbose=True):
# image = tools.smoothing(image)
pyr_imgs = []
outs = []
pyr_masks = []
for im_pyr, mask_pyr in zip(tools.pyramid(image, scale=pyr_scale, min_size=min_pyr_size, inter=cv2.INTER_NEAREST),
tools.pyramid(mask, scale=pyr_scale, min_size=min_pyr_size, inter=cv2.INTER_NEAREST)):
im_pyr, mask_pyr = tools.crop_to_bbox(im_pyr, mask_pyr)
hist, bins = skiexp.histogram(im_pyr[np.nonzero(mask_pyr)])
liver_peak = bins[np.argmax(hist)]
# if show:
# plt.figure()
# plt.plot(bins, hist, 'b-', linewidth=3)
# plt.xlim(0, 255)
# plt.plot([bins[np.argmax(hist)],] * 2, [0, hist.max()], 'r-')
# plt.plot(bins[np.argmax(hist)], hist.max(), 'ro')
# plt.gca().annotate('peak', xy=(bins[np.argmax(hist)], hist.max()), xytext=(bins[np.argmax(hist)] + 20, hist.max() + 20),
# arrowprops=dict(facecolor='black', shrink=0.05))
# if show_now:
# plt.show()
out = np.zeros(im_pyr.shape)
win_w = 10
win_h = 10
win_size = (win_w, win_h)
step_size = 4
for (x, y, win_mask, win) in tools.sliding_window(im_pyr, window_size=win_size, step_size=step_size):
win_mean = win.mean()
# suptitle = 'abs of diff'
# out_val = abs(liver_peak - win_mean)
# suptitle = 'entropy'
# out_val = skifil.rank.entropy(win, skimor.disk(3)).mean()
# suptitle = 'procent. zastoupeni hypo'
# out_val = (win < liver_peak).sum() / (win_w * win_h)
suptitle = 'procent. zastoupeni hypo + bin. open'
m = win < liver_peak
m = skimor.binary_opening(m, skimor.disk(3))
out_val = m.sum() / (win_w * win_h)
out[np.nonzero(win_mask)] = out_val
out *= mask_pyr
outs.append(out)
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
# survival image acros pyramid layers
surv_im = calc_survival_fcn(outs, pyr_masks, show=False)
if show:
n_layers = len(outs)
plt.figure()
plt.suptitle(suptitle)
for i, (im, out) in enumerate(zip(pyr_imgs, outs)):
plt.subplot(2, n_layers, i + 1), plt.imshow(im, 'gray', interpolation='nearest'), plt.title('input at pyr. layer %i' % (i + 1))
plt.axis('off')
plt.subplot(2, n_layers, i + 1 + n_layers), plt.imshow(out, 'jet', interpolation='nearest'), plt.title('output at pyr. layer %i' % (i + 1))
plt.axis('off')
plt.figure()
plt.subplot(121), plt.imshow(image, 'gray', interpolation='nearest')
plt.axis('off')
plt.subplot(122), plt.imshow(surv_im, 'jet', interpolation='nearest')
plt.axis('off')
if show_now:
plt.show()
return surv_im, pyr_imgs
def contour_test(img, mask):
img, mask = tools.crop_to_bbox(img, mask)
img_o = img.copy()
# write mean value outside the mask ----------------------------------------
mean_val = np.mean(img[np.nonzero(mask)])
img = np.where(mask, img, mean_val)
# rescale to UINT8 ---------------------------------------------------------
img = skiexp.rescale_intensity(img, out_range=np.uint8).astype(np.uint8)
# smoothing ----------------------------------------------------------------
img = tools.smoothing(img)
# Contrast stretching -----------------------------------------------------
# ps = [(2, 98), (5, 95), (10, 90), (20, 80)]
ps = [(10, 40), (10, 90)]
imgs_rescale = []
for p in ps:
pmin, pmax = np.percentile(img, p)
imgs_rescale.append(
skiexp.rescale_intensity(img, in_range=(pmin, pmax)))
# Equalization --------------------------------------------------------------
img_eq = skiexp.equalize_hist(img)
# canny edge detector -----------------------------------------------------
canny_s = tools.auto_canny(img, sigma=0.05)
cannys_res = []
for i in imgs_rescale:
cannys_res.append(tools.auto_canny(i, sigma=0.1))
canny_eq = tools.auto_canny(skiexp.rescale_intensity(
img_eq, out_range=np.uint8).astype(np.uint8),
sigma=0.1)
# morphology -------------------------------------------------------------
img_eq_morph = skimor.closing(img_eq, selem=skimor.disk(7))
# img_eq_morph = skimor.closing(imgs_rescale[0], selem=skimor.disk(7))
# plt.figure()
# plt.subplot(121), plt.imshow(img_eq, 'gray', interpolation='nearest'), plt.title('img equalized')
# plt.subplot(122), plt.imshow(img_eq_morph, 'gray', interpolation='nearest'), plt.title('closed')
# plt.show()
# contours ----------------------------------------------------------------
contours = skimea.find_contours(img_eq_morph, 0.2)
# plt.figure()
# plt.imshow(img_eq_morph, 'gray', interpolation='nearest')
# for n, contour in enumerate(contours):
# plt.plot(contour[:, 1], contour[:, 0], linewidth=2)
# plt.axis('image')
# plt.show()
# TODO: zkusit contury na canny a primo na im_eq
vmin = 50 - 175
vmax = 50 + 175
plt.figure()
plt.imshow(img_o, 'gray', interpolation='nearest', vmin=vmin, vmax=vmax)
for (im, p) in zip(imgs_rescale, ps):
plt.figure()
plt.subplot(121), plt.imshow(im, 'gray',
interpolation='nearest'), plt.title(
'contrast stretching - {}'.format(p))
plt.subplot(122), plt.imshow(
skimor.closing(im, selem=skimor.disk(3)),
'gray',
interpolation='nearest'), plt.title('closing')
plt.figure()
plt.imshow(img_eq, 'gray', interpolation='nearest')
plt.title('equalization')
# PLOT CANNY -------------------------------------------
# plt.figure()
# plt.imshow(canny_s, 'gray', interpolation='nearest')
# plt.title('canny - smoothed')
# for (im, p) in zip(cannys_res, ps):
# plt.figure()
# plt.imshow(im, 'gray', interpolation='nearest')
# plt.title('canny - contrast stretching - {}'.format(p))
# plt.figure()
# plt.imshow(canny_eq, 'gray', interpolation='nearest')
# plt.title('canny - equalization')
plt.show()
plt.subplot(246), plt.imshow(cout, 'gray', interpolation='nearest'), plt.title('cout')
plt.subplot(247), plt.imshow(saliency, 'gray', interpolation='nearest'), plt.title('saliency')
plt.subplot(248), plt.imshow(saliency_mark_max, 'gray', interpolation='nearest'), plt.title('saliency_mark_max')
if show_now:
plt.show()
if return_all:
return intensty, gabor, rg, by, cout, saliency, saliency_mark_max
else:
return im_orig, im, saliency
#---------------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------------
if __name__ == "__main__":
data_fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_183_46324212_venous_5.0_B30f-.pklz'
data, mask, voxel_size = tools.load_pickle_data(data_fname)
slice_ind = 17
data_s = data[slice_ind, :, :]
data_s = tools.windowing(data_s)
mask_s = mask[slice_ind, :, :]
data_s, mask_s = tools.crop_to_bbox(data_s, mask_s)
mean_v = int(data_s[np.nonzero(mask_s)].mean())
data_s = np.where(mask_s, data_s, mean_v)
# data_s *= mask_s.astype(data_s.dtype)
im = cv2.cvtColor(data_s, cv2.COLOR_BAYER_GR2RGB)
# run(im, save_fig=False, show=True, show_now=False)
run(im, smoothing=True, save_fig=False, show=True)
def run(image,
mask,
pyr_scale,
blob_type,
show=False,
show_now=True,
save_fig=False,
verbose=True):
set_verbose(verbose)
fig_dir = '/home/tomas/Dropbox/Work/Dizertace/figures/blobs/%s/' % blob_type
if save_fig:
if not os.path.exists(fig_dir):
os.mkdir(fig_dir)
image, mask = tools.crop_to_bbox(image, mask)
image = tools.smoothing(image, sliceId=0)
blobs_pyr = []
survs_pyr = []
titles_pyr = []
pyr_imgs = []
pyr_masks = []
for layer_id, (im_pyr, mask_pyr) in enumerate(
zip(tools.pyramid(image, scale=pyr_scale, inter=cv2.INTER_NEAREST),
tools.pyramid(mask, scale=pyr_scale,
inter=cv2.INTER_NEAREST))):
blobs_res, survs_res, titles, params = detect_blobs(im_pyr,
mask_pyr,
blob_type,
layer_id=layer_id,
show=show,
show_now=show_now,
save_fig=save_fig,
verbose=verbose)
blobs_pyr.append(blobs_res)
survs_pyr.append(survs_res)
titles_pyr.append(titles)
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
n_layers = len(pyr_imgs)
n_params = len(
survs_pyr[0]) - 1 # -1 because the first surv is overall surv
# survival layers
# for layer_id, layer in enumerate(survs_pyr):
# fig_surv_layer =
# for im in layer[1:]: # the first surv is overall
# surv_layer += im
# surv_im_layers.append(surv_layer)
# survival param -
# survival overall
surv_overall = np.zeros(image.shape)
for survs_l in survs_pyr:
surv_overall += cv2.resize(survs_l[0], image.shape[::-1])
# responses
all_blobs = []
for layer_id, layer_p in enumerate(blobs_pyr):
scale = pyr_scale**layer_id
for blobs in layer_p[0]:
if len(blobs) > 0:
for blob in blobs:
y, x, r = blob
all_blobs.append((scale * y, scale * x, scale * r))
if show or save_fig:
# SURVIVAL IMAGES ----------
# survival fcn - params per layer, number = n_layers
for layer_id, survs_l in enumerate(survs_pyr):
fig_surv_layer = plt.figure(figsize=(24, 14))
for param_id, (im, tit) in enumerate(
zip(survs_l[1:], titles_pyr[layer_id][1:])):
plt.subplot(1, n_params, param_id + 1)
plt.imshow(im, 'jet', interpolation='nearest')
plt.title(tit)
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
fig_surv_layer.savefig(os.path.join(
fig_dir, '%s_surv_layer_%i.png' % (blob_type, layer_id)),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if not show:
plt.close('all')
elif blob_type == BLOB_CV: # need to spare memory
plt.show()
# survival fcn - layers per param, number = n_params
for param_id in range(n_params):
fig_surv_layer = plt.figure(figsize=(24, 14))
for layer_id, survs_l in enumerate(survs_pyr):
plt.subplot(1, n_layers, layer_id + 1)
plt.imshow(survs_l[param_id + 1],
'jet',
interpolation='nearest'
) # +1 because the first surv is the overall surv
plt.title(titles_pyr[layer_id]
[param_id +
1]) # +1 because the first surv is the overall surv
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
fig_surv_layer.savefig(os.path.join(
fig_dir, '%s_surv_%s.png' % (blob_type, params[param_id])),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if not show:
plt.close('all')
elif blob_type == BLOB_CV: # need to spare memory
plt.show()
# survival fcn - layers, number = 1, [layer1, layer2, ...]
fig_surv_layers = plt.figure(figsize=(24, 14))
for layer_id, survs_l in enumerate(survs_pyr):
plt.subplot(1, n_layers, layer_id + 1)
plt.imshow(survs_l[0], 'jet', interpolation='nearest')
plt.title('layer #%i, surv' % (layer_id + 1))
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
# survival fcn - params, number = 1, [param1, param2, ...]
surv_params = []
for i in range(n_params):
surv_params.append(np.zeros(image.shape))
for layer in survs_pyr:
for i, surv in enumerate(
layer[1:]): # from 1 because the first surv is overall
surv_params[i] += cv2.resize(surv, image.shape[::-1])
fig_surv_params = plt.figure(figsize=(24, 14))
for param_id, (surv_p, param) in enumerate(zip(surv_params, params)):
plt.subplot(1, n_params, param_id + 1)
plt.imshow(surv_p, 'jet', interpolation='nearest')
plt.title('%s, surv' % param)
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
# survival fcn - overall, number = 1
fig_surv = plt.figure(figsize=(24, 14))
plt.subplot(121), plt.imshow(
image, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(122), plt.imshow(surv_overall,
'jet',
interpolation='nearest')
plt.title('%s - overall survival fcn' % blob_type)
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
# RESPONSE IMAGES ----------
# response image - layers per param, number = n_params, [p1l1, p1l2, ...]
for param_id in range(n_params):
fig_resps_layer = plt.figure(figsize=(24, 14))
for layer_id, blobs_l in enumerate(blobs_pyr):
plt.subplot(1, n_layers, layer_id + 1)
plt.imshow(pyr_imgs[layer_id], 'gray', interpolation='nearest')
for blobs in blobs_l[param_id + 1]:
if len(blobs) > 0:
for blob in blobs:
y, x, r = blob
c = plt.Circle((x, y),
r,
color='r',
linewidth=2,
fill=False)
plt.gca().add_patch(c)
plt.title(titles_pyr[layer_id]
[param_id +
1]) # +1 because the first surv is the overall surv
if save_fig:
fig_resps_layer.savefig(os.path.join(
fig_dir,
'%s_resps_%s.png' % (blob_type, params[param_id])),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if not show:
plt.close('all')
elif blob_type == BLOB_CV: # need to spare memory
plt.show()
# response image - params per layer, number = n_layers, [l1p1, l1p2, ...]
for layer_id, blobs_l in enumerate(blobs_pyr):
fig_resps_layer = plt.figure(figsize=(24, 14))
for param_id, (param, tit) in enumerate(
zip(params, titles_pyr[layer_id][1:])):
plt.subplot(1, n_params, param_id + 1)
plt.imshow(pyr_imgs[layer_id], 'gray', interpolation='nearest')
for blobs in blobs_l[param_id + 1]:
if len(blobs) > 0:
for blob in blobs:
y, x, r = blob
c = plt.Circle((x, y),
r,
color='r',
linewidth=2,
fill=False)
plt.gca().add_patch(c)
plt.title(tit)
if save_fig:
fig_resps_layer.savefig(os.path.join(
fig_dir, '%s_resps_layer_%i.png' % (blob_type, layer_id)),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if not show:
plt.close('all')
elif blob_type == BLOB_CV: # need to spare memory
plt.show()
# response image - params, number = 1, [param1, param2, ...]
fig_resps_params = plt.figure(figsize=(24, 14))
for param_id, param in enumerate(params):
for layer_id, blobs_l in enumerate(blobs_pyr):
scale = pyr_scale**layer_id
plt.subplot(1, n_params, param_id + 1)
plt.imshow(pyr_imgs[0], 'gray', interpolation='nearest')
for blobs in blobs_l[param_id + 1]:
if len(blobs) > 0:
for blob in blobs:
y, x, r = blob
c = plt.Circle((scale * x, scale * y),
scale * r,
color='r',
linewidth=2,
fill=False)
plt.gca().add_patch(c)
plt.title('%s' % param)
# response image - layers, number = 1
fig_resps_layers = plt.figure(figsize=(24, 14))
for layer_id, blobs_l in enumerate(blobs_pyr):
plt.subplot(1, n_layers, layer_id + 1)
plt.imshow(pyr_imgs[layer_id], 'gray', interpolation='nearest')
for blobs in blobs_l[0]:
if len(blobs) > 0:
for blob in blobs:
y, x, r = blob
c = plt.Circle((x, y),
r,
color='r',
linewidth=2,
fill=False)
plt.gca().add_patch(c)
plt.title('layer #%i' % (layer_id + 1))
# response image - overall, number = 1
fig_resp = plt.figure(figsize=(24, 14))
plt.subplot(121), plt.imshow(
image, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(122), plt.imshow(image, 'gray', interpolation='nearest')
for blob in all_blobs:
y, x, r = blob
c = plt.Circle((x, y), r, color='r', linewidth=2, fill=False)
plt.gca().add_patch(c)
plt.title('%s - overall response image' % blob_type)
if save_fig:
fig_surv.savefig(os.path.join(fig_dir,
'%s_surv_overall.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_surv_layers.savefig(os.path.join(
fig_dir, '%s_surv_layers.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_surv_params.savefig(os.path.join(
fig_dir, '%s_surv_params.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_resp.savefig(os.path.join(fig_dir,
'%s_resps_overall.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_resps_layers.savefig(os.path.join(
fig_dir, '%s_resps_layers.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_resps_params.savefig(os.path.join(
fig_dir, '%s_resps_params.png' % blob_type),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if show_now:
plt.show()
return surv_overall, survs_pyr, pyr_imgs, pyr_masks
def run(image,
mask,
type='dark',
pyr_scale=2.,
min_pyr_size=20,
show=False,
show_now=True,
save_fig=False,
verbose=True):
set_verbose(verbose)
fig_dir = '/home/tomas/Dropbox/Work/Dizertace/figures/circloids/'
image = tools.smoothing(image)
image_bb, mask_bb = tools.crop_to_bbox(image, mask)
# mask_shapes = [(5, 5, 0), (9, 5, 0), (9, 5, 45), (9, 5, 90), (9, 5, 135)]
mask_shapes = [(15, 15, 0), (29, 15, 0), (29, 15, 45), (29, 15, 90),
(29, 15, 135)]
n_masks = len(mask_shapes)
border_width = 1
_debug('Creating masks...')
masks, elipses = create_masks(mask_shapes,
border_width=border_width,
show=False,
show_masks=False)
# filters_fig = plt.figure(figsize=(24, 14))
# for m_id, m in enumerate(masks):
# mask_lab = np.zeros(m[0].shape, dtype=np.byte)
# for i, j in enumerate(m):
# mask_lab += (i + 1) * j
# plt.subplot(1, n_masks, m_id + 1)
# plt.imshow(mask_lab, 'jet', interpolation='nearest')
# filters_fig.savefig(os.path.join(fig_dir, 'masks.png'), dpi=100, bbox_inches='tight', pad_inches=0)
# plt.show()
pyr_imgs = []
pyr_masks = []
pyr_positives = []
pyr_outs = []
pyr_elip_imgs = []
if save_fig:
if not os.path.exists(fig_dir):
os.mkdir(fig_dir)
_debug('Calculating responses...')
for layer_id, (im_pyr, mask_pyr) in enumerate(
zip(tools.pyramid(image, scale=pyr_scale, inter=cv2.INTER_NEAREST),
tools.pyramid(mask, scale=pyr_scale,
inter=cv2.INTER_NEAREST))):
im_pyr, mask_pyr = tools.crop_to_bbox(im_pyr, mask_pyr)
# setting up values outside mask to better suppress responses on the border of the mask
if type == 'dark':
im_pyr = np.where(mask_pyr, im_pyr, 0)
else:
im_pyr = np.where(mask_pyr, im_pyr, 255)
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
hist, bins = skiexp.histogram(im_pyr[np.nonzero(mask_pyr)])
liver_peak = bins[np.argmax(hist)]
layer_positives = [
] # list of candidates for current layer and all masks
layer_outs = []
layer_elip_imgs = [] # list of pyramid layers with elipse overlays
for mask_id, (m, e) in enumerate(zip(masks, elipses)):
mask_positives = []
win_size = m[0].shape[::-1]
step_size = 4
for (x, y, win_mask,
win) in tools.sliding_window(im_pyr,
window_size=win_size,
step_size=step_size,
mask=mask_pyr):
resp, m_resps = masks_response(win,
m,
type=type,
mean_val=liver_peak,
show=False)
if resp:
# positives.append(((x, y), (x + win_size[0], y + win_size[1])))
elip = ((e[0][0] + x, e[0][1] + y), e[1], e[2])
mask_positives.append(elip)
layer_positives.append(mask_positives)
# creating out image and elip image
mask_outs = np.zeros(im_pyr.shape)
mask_elip = cv2.cvtColor(im_pyr.copy(), cv2.COLOR_GRAY2BGR)
for i in mask_positives:
tmp = np.zeros(im_pyr.shape)
cv2.ellipse(tmp, i[0], i[1], i[2], 0, 360, 1, thickness=-1)
cv2.ellipse(mask_elip,
i[0],
i[1],
i[2],
0,
360, (255, 0, 255),
thickness=1)
mask_outs += tmp
layer_outs.append(mask_outs)
layer_elip_imgs.append(mask_elip)
pyr_positives.append(layer_positives)
pyr_outs.append(layer_outs)
pyr_elip_imgs.append(layer_elip_imgs)
n_layers = len(pyr_imgs)
# survival image for masks
surv_im_masks = []
for i in range(n_masks):
surv_im_masks.append(np.zeros(image_bb.shape))
for layer in pyr_outs:
for i, mask_resp in enumerate(layer):
surv_im_masks[i] += cv2.resize(mask_resp, image_bb.shape[::-1])
# survival image for pyramid layers
surv_im_layers = []
for i, layer in enumerate(pyr_outs):
surv_layer = np.zeros(layer[0].shape)
for mask_resp in layer:
surv_layer += mask_resp
surv_im_layers.append(surv_layer)
# survival image - overall
all_outs = [im for layer in pyr_outs for im in layer]
surv_im_pyr = np.zeros(image_bb.shape)
for im_out in all_outs:
surv_im_pyr += cv2.resize(im_out, image_bb.shape[::-1])
# responses - overall
resp_im_pyr = cv2.cvtColor(image_bb, cv2.COLOR_GRAY2RGB)
for layer_id, layer_p in enumerate(pyr_positives):
scale = pyr_scale**layer_id
for mask_r in layer_p:
for r in mask_r:
cv2.ellipse(resp_im_pyr,
tuple([int(scale * x) for x in r[0]]),
tuple([int(scale * x) for x in r[1]]),
r[2],
0,
360, (255, 0, 255),
thickness=1)
# responses - layers
resp_im_layers = []
for layer_id, layer_p in enumerate(pyr_positives):
resp_layer = cv2.cvtColor(pyr_imgs[layer_id], cv2.COLOR_GRAY2RGB)
for mask_r in layer_p:
for r in mask_r:
# cv2.ellipse(resp_layer, tuple([int(scale * x) for x in r[0]]), tuple([int(scale * x) for x in r[1]]), r[2], 0, 360, (255, 0, 255), thickness=1)
cv2.ellipse(resp_layer,
r[0],
r[1],
r[2],
0,
360, (255, 0, 255),
thickness=1)
resp_im_layers.append(resp_layer)
# responses - masks
resp_im_masks = []
for i in range(n_masks):
resp_im_masks.append(cv2.cvtColor(image_bb, cv2.COLOR_GRAY2RGB))
for layer_id, layer_p in enumerate(pyr_positives):
scale = pyr_scale**layer_id
for mask_id, mask_r in enumerate(layer_p):
for r in mask_r:
cv2.ellipse(resp_im_masks[mask_id],
tuple([int(scale * x) for x in r[0]]),
tuple([int(scale * x) for x in r[1]]),
r[2],
0,
360, (255, 0, 255),
thickness=1)
# SHOWING AND SAVING RESULTS -----------------------------------------------------------------
if show:
# masks
filters_fig = plt.figure(figsize=(24, 14))
for m_id, m in enumerate(masks):
mask_lab = np.zeros(m[0].shape, dtype=np.byte)
for i, j in enumerate(m):
mask_lab += (i + 1) * j
plt.subplot(1, n_masks, m_id + 1)
plt.imshow(mask_lab, 'jet', interpolation='nearest')
if save_fig:
filters_fig.savefig(os.path.join(fig_dir, 'masks.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# responses - figure shows masks resps in a pyramid layer
for layer_id, layer in enumerate(pyr_elip_imgs):
layer_fig = plt.figure(figsize=(24, 14))
# plt.suptitle('layer #%i' % (layer_id + 1))
for mask_id, mask_outs in enumerate(layer):
plt.subplot(1, len(mask_shapes), mask_id + 1)
plt.imshow(mask_outs, interpolation='nearest')
plt.title('layer #%i, mask #%i' % (layer_id + 1, mask_id + 1))
if save_fig:
layer_fig.savefig(os.path.join(
fig_dir, 'resps_layer_%i.png' % (layer_id + 1)),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# responses - overall
resp_fig = plt.figure(figsize=(24, 14))
plt.subplot(121), plt.imshow(pyr_imgs[0],
'gray',
interpolation='nearest')
plt.title('input')
plt.subplot(122), plt.imshow(resp_im_pyr, interpolation='nearest')
plt.title('overall responses')
if save_fig:
resp_fig.savefig(os.path.join(fig_dir, 'resps_overall.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# responses - layers
resp_layer_fig = plt.figure(figsize=(24, 14))
for i, resp_l in enumerate(resp_im_layers):
plt.subplot(1, n_layers, i + 1)
plt.imshow(resp_l, interpolation='nearest')
plt.title('resps for layer #%i' % (i + 1))
if save_fig:
resp_layer_fig.savefig(os.path.join(fig_dir, 'resps_layers.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# responses - masks
resp_mask_fig = plt.figure(figsize=(24, 14))
for i, resp_m in enumerate(resp_im_masks):
plt.subplot(1, n_masks, i + 1)
plt.imshow(resp_m, interpolation='nearest')
plt.title('resps for mask #%i' % (i + 1))
if save_fig:
resp_mask_fig.savefig(os.path.join(fig_dir, 'resps_masks.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# survival image - layers
surv_layer_fig = plt.figure(figsize=(24, 14))
for i, surv_l in enumerate(surv_im_layers):
plt.subplot(1, len(surv_im_layers), i + 1)
plt.imshow(surv_l, interpolation='nearest')
plt.title('surv im for layer #%i' % (i + 1))
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
surv_layer_fig.savefig(os.path.join(fig_dir, 'surv_im_layers.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# survival image - masks
surv_mask_fig = plt.figure(figsize=(24, 14))
for i, surv_m in enumerate(surv_im_masks):
plt.subplot(1, len(surv_im_masks), i + 1)
plt.imshow(surv_m, interpolation='nearest')
plt.title('surv im for mask #%i' % (i + 1))
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
surv_mask_fig.savefig(os.path.join(fig_dir, 'surv_im_masks.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
# survival image - overall
surv_fig = plt.figure(figsize=(24, 14))
plt.subplot(121), plt.imshow(pyr_imgs[0],
'gray',
interpolation='nearest')
plt.title('input')
plt.subplot(122), plt.imshow(surv_im_pyr, interpolation='nearest')
plt.title('overall survival fcn')
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
surv_fig.savefig(os.path.join(fig_dir, 'surv_im_overall.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if show_now:
plt.show()
return surv_im_pyr, surv_im_layers, surv_im_masks
def run(image,
mask=None,
n_points=24,
radius=3,
lbp_type='flat',
blob_type='hypo',
pyr_scale=2,
show=False,
show_now=True,
save_fig=False,
verbose=True):
set_verbose(verbose)
if mask is None:
mask = np.ones_like(image)
image, mask = tools.crop_to_bbox(image, mask)
image = tools.smoothing(image, sliceId=0)
lbp_pyr = []
pyr_imgs = []
pyr_masks = []
for layer_id, (im_pyr, mask_pyr) in enumerate(
zip(tools.pyramid(image, scale=pyr_scale, inter=cv2.INTER_NEAREST),
tools.pyramid(mask, scale=pyr_scale,
inter=cv2.INTER_NEAREST))):
lbp_res = local_binary_pattern(im_pyr, n_points, radius, 'uniform')
w = radius - 1
lbp_prototype = find_prototypes(im_pyr,
mask_pyr,
lbp_res,
lbp_type,
blob_type,
w,
n_points,
k=1)
lbp_pyr.append(lbp_prototype.astype(np.float))
pyr_imgs.append(im_pyr)
pyr_masks.append(mask_pyr)
# survival overall
surv_overall = np.zeros(image.shape)
for surv_l in lbp_pyr:
surv_overall += cv2.resize(surv_l, image.shape[::-1])
# visualization
if show:
n_layers = len(lbp_pyr)
imgs = [image, surv_overall] + lbp_pyr
n_non_layers = len(imgs) - len(lbp_pyr)
titles = ['input', 'surv'
] + ['layer #%i' % (i + 1) for i in range(n_layers)]
to_rgb = [
0,
0,
] + n_layers * [
1,
]
cmaps = ['gray', 'jet'] + n_layers * ['jet']
plt.figure()
for i, (im, tit, cmap,
conv) in enumerate(zip(imgs, titles, cmaps, to_rgb)):
plt.subplot(1, n_layers + n_non_layers, i + 1)
if conv:
plt.imshow(label2rgb(im,
image=pyr_imgs[i - n_non_layers],
bg_label=0,
alpha=0.5),
interpolation='nearest')
else:
plt.imshow(im, cmap, interpolation='nearest')
# if i == 1:
# plt.colorbar(ticks=np.unique(im.astype(np.int)))
plt.title(tit)
# plt.subplot(132), plt.imshow(label2rgb(hypo_m, image=im_bb, bg_label=0, alpha=0.5)), plt.title('input < input.mean()')
# plt.subplot(133), plt.imshow(label2rgb(hypo_lbp, image=im_bb, bg_label=0, alpha=0.5)), plt.title('hypo lbp')
# plt.figure()
# counts, _, bars = plt.hist(lbp.ravel(), normed=True, bins=lbp.max() + 1, range=(0, lbp.max() + 1), facecolor='0.5')
# for i in flat_labels:
# bars[i].set_facecolor('r')
# plt.gca().set_ylim(ymax=np.max(counts[:-1]))
# plt.gca().set_xlim(xmax=n_points + 2)
# plt.title('lbp hist with highlighted flat prototypes')
if show_now:
plt.show()
return surv_overall, lbp_pyr
def run(data,
mask,
voxel_size,
is_2D=False,
bboxing=False,
return_vis=False,
show=False,
show_now=True,
save_fig=False):
data_w = tools.windowing(data).astype(np.uint8)
data_s = tools.smoothing(data_w, sliceId=0) * (mask > 0)
data_rgb = np.zeros((data_s.shape[1], data_s.shape[2], 3, data_s.shape[0]))
for i, s in enumerate(data_s):
data_rgb[:, :, :, i] = cv2.cvtColor(s, cv2.COLOR_BAYER_GR2RGB)
data_rgb = np.swapaxes(data_rgb, 2, 3)
slics = skiseg.slic(data_rgb,
spacing=np.roll(voxel_size, 2),
multichannel=True,
n_segments=10)
# slics = skiseg.slic(data_rgb, spacing=np.roll(voxel_size, 2), multichannel=True, n_segments=100,
# slic_zero=True, enforce_connectivity=True)
slics = np.swapaxes(np.swapaxes(slics, 1, 2), 0, 1) * (mask > 0)
# tools.show_3d(slics)
slics_big = np.zeros_like(slics)
if is_2D:
areaT = 500
else:
areaT = 6000
for i in np.unique(slics):
slic = tools.opening3D(slics == i, selem=skimor.disk(3))
area = slic.sum()
if area > areaT:
slics_big = np.where(slic, slics, slics_big)
# tools.show_3d((data, slics, slics_big))
if not return_vis:
return slics_big
vis = []
for i, (im, slic, slic_b,
mask_s) in enumerate(zip(data_w, slics, slics_big, mask)):
vis_s = []
if bboxing:
im, mask_bb = tools.crop_to_bbox(im, mask_s)
slic, mask_bb = tools.crop_to_bbox(slic, mask_s)
slic_b, mask_bb = tools.crop_to_bbox(slic_b, mask_s)
vis_s.append(('input', im))
vis_s.append(('slic', slic))
vis_s.append(('thresholded slic', slic_b))
vis_s.append(
('boundaries', skiseg.mark_boundaries(im, slic_b,
color=(1, 0, 1))))
vis.append(vis_s)
# ranges for visualization
ranges = [(0, 255), (slics.min(), slics.max()),
(slics_big.min(), slics_big.max()), (0, 255)]
# colormaps
cmaps = ['gray', 'gray', 'jet', 'gray']
if show or save_fig:
n_imgs = len(vis[0])
# pbar = progressbar.ProgressBar(maxval=len(vis), widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()])
# widgets = ["Seting up figures: ", progressbar.Percentage(), " ", progressbar.Bar(), " ", progressbar.ETA()]
# pbar = progressbar.ProgressBar(maxval=len(vis), widgets=widgets)
# pbar.start()
for slice_id, (v, mask_s) in enumerate(zip(vis, mask)):
fig = plt.figure(figsize=(24, 14))
for i, ((tit, im), rg, cm) in enumerate(zip(v, ranges, cmaps)):
# tit = v[slice_id][i][0]
# im = v[slice_id][i][1]
# im_bb, mask_bb = tools.crop_to_bbox(im, mask_s)
plt.subplot(1, n_imgs, i + 1)
plt.imshow(im,
cmap=cm,
vmin=rg[0],
vmax=rg[1],
interpolation='nearest')
plt.title(tit)
if save_fig:
fig_dir = '/home/tomas/Dropbox/Work/Dizertace/figures/slics/'
dirs = fig_dir.split(os.sep)
for i in range(2, len(dirs)):
subdir = os.sep.join(dirs[:i])
if not os.path.exists(subdir):
os.mkdir(subdir)
if is_2D:
dirname = os.path.join(
fig_dir, 'slics_vis_2D_slice_%i.png' % (slice_id + 1))
else:
dirname = os.path.join(
fig_dir, 'slics_vis_slice_%i.png' % (slice_id + 1))
fig.savefig(dirname,
dpi=100,
bbox_inches='tight',
pad_inches=0)
plt.close('all')
# pbar.update(slice_id)
# pbar.finish()
if show_now:
plt.show()
return slics_big, vis, ranges, cmaps
def run(im, mask=None, save_fig=False, smoothing=False, return_all=False, show=False, show_now=True):
if mask is None:
mask = np.ones(im.shape[:-1])
im_orig = im.copy()
else:
im, mask = tools.crop_to_bbox(im, mask)
im_orig = im.copy()
mean_v = int(im[np.nonzero(mask)].mean())
im = np.where(mask, im, mean_v)
if im.ndim == 2:
im = cv2.cvtColor(im, cv2.COLOR_BAYER_GR2RGB)
# im = cv2.cvtColor(im, cv2.COLOR_GRAY2RGB)
im_orig = im.copy()
orig_shape = im_orig.shape[:-1]
if smoothing:
im = tools.smoothing(im)
# img = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY)
# im *= im < np.median(im)
# img = cv2.resize(img, (intensty.shape[1], intensty.shape[0]))
intensty = intensityConspicuity(im)
# intensty *= img < np.median(img)
# intensty2 = intensty * (img < np.median(img))
gabor = gaborConspicuity(im, 4)
im = makeNormalizedColorChannels(im)
rg = rgConspicuity(im)
by = byConspicuity(im)
c = rg + by
saliency = 1./3 * (N(intensty) + N(c) + N(gabor))
saliency_mark_max = markMaxima(saliency)
cout = .25 * c
# saliency_nonN = 1./3 * (intensty + c + gabor)
# saliency_nonN = cv2.resize(saliency_nonN, dsize=orig_shape[::-1]) * mask
intensty = cv2.resize(intensty, dsize=orig_shape[::-1]) * mask
gabor = cv2.resize(gabor, dsize=orig_shape[::-1]) * mask
rg = cv2.resize(rg, dsize=orig_shape[::-1]) * mask
by = cv2.resize(by, dsize=orig_shape[::-1]) * mask
cout = cv2.resize(cout, dsize=orig_shape[::-1]) * mask
saliency = cv2.resize(saliency, dsize=orig_shape[::-1]) * mask
saliency_mark_max = cv2.resize(saliency_mark_max, dsize=orig_shape[::-1])
# morphology
# saliency2 = skimor.closing(saliency, selem=skimor.disk(5))
# saliency3 = skimor.white_tophat(saliency, selem=skimor.disk(10))
# plt.figure(figsize=(24, 14))
# plt.subplot(131), plt.imshow(saliency, 'jet', interpolation='nearest'), plt.title('saliency')
# plt.subplot(132), plt.imshow(saliency2, 'jet', interpolation='nearest'), plt.title('saliency + gray morph close (disk(3))')
# plt.subplot(133), plt.imshow(saliency3, 'jet', interpolation='nearest'), plt.title('saliency + white top hat (disk(3))')
# plt.show()
# plt.figure()
# plt.subplot(241), plt.imshow(intensty, 'gray', interpolation='nearest'), plt.title('intensity')
# plt.subplot(245), plt.imshow(N(intensty), 'gray', interpolation='nearest'), plt.title('norm intensity')
# plt.subplot(242), plt.imshow(gabor, 'gray', interpolation='nearest'), plt.title('gabor')
# plt.subplot(246), plt.imshow(N(gabor), 'gray', interpolation='nearest'), plt.title('norm gabor')
# plt.subplot(243), plt.imshow(rg, 'gray', interpolation='nearest'), plt.title('rg')
# plt.subplot(247), plt.imshow(N(rg), 'gray', interpolation='nearest'), plt.title('norm rg')
# plt.subplot(244), plt.imshow(by, 'gray', interpolation='nearest'), plt.title('by')
# plt.subplot(248), plt.imshow(N(by), 'gray', interpolation='nearest'), plt.title('norm by')
#
# plt.figure()
# plt.subplot(121), plt.imshow(saliency, 'gray', interpolation='nearest'), plt.title('saliency N')
# plt.subplot(122), plt.imshow(saliency_nonN, 'gray', interpolation='nearest'), plt.title('saliency')
# plt.show()
saliency = skiexp.rescale_intensity(saliency, out_range=(0, 1))
if save_fig:
save_figs(intensty, gabor, rg, by, cout, saliency, saliency_mark_max)
if show:
plt.figure()
plt.subplot(241), plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(242), plt.imshow(intensty, 'gray', interpolation='nearest'), plt.title('intensity')
plt.subplot(243), plt.imshow(gabor, 'gray', interpolation='nearest'), plt.title('gabor')
plt.subplot(244), plt.imshow(rg, 'gray', interpolation='nearest'), plt.title('rg')
plt.subplot(245), plt.imshow(by, 'gray', interpolation='nearest'), plt.title('by')
plt.subplot(246), plt.imshow(cout, 'gray', interpolation='nearest'), plt.title('cout')
plt.subplot(247), plt.imshow(saliency, 'gray', interpolation='nearest'), plt.title('saliency')
plt.subplot(248), plt.imshow(saliency_mark_max, 'gray', interpolation='nearest'), plt.title('saliency_mark_max')
if show_now:
plt.show()
if return_all:
return intensty, gabor, rg, by, cout, saliency, saliency_mark_max
else:
return im_orig, im, saliency
def run(im, mask, alpha=1, beta=1, scale=0.5, show=False, show_now=True, save_fig=False, verbose=True):
# scale = 0.5 # scaling parameter for resizing the image
# alpha = 1 # parameter for weighting the smoothness term (pairwise potentials)
# beta = 1 # parameter for weighting the data term (unary potentials)
set_verbose(verbose)
figdir = '/home/tomas/Dropbox/Work/Dizertace/figures/mrf'
_debug('Calculating saliency maps...')
im_orig, image, salaki_map = salaki.run(im, mask)
im_orig, image, salgoo_map = salgoo.run(im, mask=mask)
im_orig, _, salik_map = salik.run(im, mask=mask, smoothing=True)
im_orig, image, salmay_map = salmay.run(im, mask=mask, smoothing=True)
# inverting intensity so that the tumor has high saliency
# salgoo_map = np.where(salgoo_map, 1 - salgoo_map, 0)
# salik_map = skiexp.rescale_intensity(salik_map, out_range=(0, 1))
saliencies = [salaki_map, salgoo_map, salik_map, salmay_map]
t**s = ['akisato', 'google', 'ik', 'mayo']
# saliencies = [salaki_map, salgoo_map, salmay_map]
# t**s = ['akisato', 'google', 'mayo']
# plt.figure()
# for i, (im, tit) in enumerate(zip(saliencies, t**s)):
# # plt.subplot(2, 2, i+1), plt.imshow(skiexp.rescale_intensity(im, out_range=(0, )), 'gray', interpolation='nearest')
# plt.subplot(2, 2, i+1), plt.imshow(im, 'gray', interpolation='nearest')
# plt.colorbar()
# plt.title(tit)
# plt.show()
im_bb, mask_bb = tools.crop_to_bbox(im, mask)
im_bb = tools.smoothing(im_bb, sliceId=0)
_debug('Creating MRF object...')
mrf = MarkovRandomField(im_bb, mask=mask_bb, models_estim='hydohy', alpha=alpha, beta=beta, scale=scale, verbose=False)
mrf.params['unaries_as_cdf'] = 1
mrf.params['perc'] = 30
mrf.params['domin_simple_estim'] = 0
mrf.params['prob_w'] = 0.1
# mrf.set_unaries(mrf.get_unaries())
unaries, probs = mrf.get_unaries(ret_prob=True)
unaries_l = [unaries[:, :, x].reshape(im_bb.shape) * mask_bb for x in range(unaries.shape[-1])]
probs_l = [probs[:, :, x].reshape(im_bb.shape) * mask_bb for x in range(probs.shape[-1])]
if show:
tools.arange_figs(unaries_l, t**s=['unaries hypo', 'unaries domin', 'unaries hyper'], max_r=1, colorbar=True, same_range=False, show_now=False)
tools.arange_figs(probs_l, t**s=['prob hypo', 'prob domin', 'prob hyper'], max_r=1, colorbar=True, same_range=False, show_now=True)
# res = mrf.run(resize=False)
# res = res[0, :, :]
# res = np.where(mask_bb, res, -1) + 1
# plt.figure()
# plt.subplot(121), plt.imshow(im_bb, 'gray'), plt.colorbar()
# plt.subplot(122), plt.imshow(res, 'jet', interpolation='nearest')
# plt.colorbar(ticks=range(mrf.n_objects + 1))
# # mrf.plot_models(show_now=False)
# plt.show()
# unaries2 = mrf.get_unaries()
# mrf.set_unaries(unaries2)
# res2 = mrf.run(resize=False)
# res2 = res2[0, :, :]
# res2 = np.where(mask_bb, res2, -1) + 1
#
# plt.figure()
# plt.subplot(121), plt.imshow(im_bb, 'gray'), plt.colorbar()
# plt.subplot(122), plt.imshow(res2, 'jet', interpolation='nearest')
# plt.colorbar(ticks=range(mrf.n_objects + 1))
# plt.show()
# plt.figure()
# plt.subplot(221), plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
# plt.subplot(222), plt.imshow(res, interpolation='nearest'), plt.title('result')
# plt.subplot(223), plt.imshow(mrf.get_unaries[:, 0, 0].reshape(im_orig.shape), 'gray', interpolation='nearest')
# plt.colorbar(), plt.title('unary #1')
# plt.subplot(224), plt.imshow(mrf.get_unaries[:, 0, 1].reshape(im_orig.shape), 'gray', interpolation='nearest')
# plt.colorbar(), plt.title('unary #2')
# plt.show()
unary_domin = mrf.get_unaries()[:, :, 1]
max_prob = unary_domin.max()
# plt.figure()
# plt.subplot(121), plt.imshow(im_bb, 'gray')
# plt.subplot(122), plt.imshow(unary_domin.reshape(im_bb.shape), 'gray', interpolation='nearest')
# plt.show()
# rescaling intensities
# max_int = 0.5
max_int = max_prob
saliencies_inv = []
for i, im in enumerate(saliencies):
saliencies[i] = skiexp.rescale_intensity(im, out_range=(0, max_int)).astype(unary_domin.dtype)
saliencies_inv.append(skiexp.rescale_intensity(im, out_range=(max_int, 0)).astype(unary_domin.dtype))
# if scale != 0:
# for i, im in enumerate(saliencies):
# saliencies[i] = tools.resize3D(im, scale, sliceId=0)
unaries_domin_sal = [np.dstack((unary_domin, x.reshape(-1, 1))) for x in saliencies_inv]
# unaries_domin_sal = [np.dstack((y.reshape(-1, 1), x.reshape(-1, 1))) for y, x in zip(saliencies, saliencies_inv)]
alphas = [1, 10, 100]
beta = 1
for alpha in alphas:
mrf = MarkovRandomField(im_bb, mask=mask_bb, models_estim='hydohy', alpha=alpha, beta=beta, scale=scale,
verbose=False)
results = []
for i, unary in enumerate(unaries_domin_sal):
_debug('Optimizing MRF with unary term: %s' % t**s[i])
# mrf.set_unaries(unary.astype(np.int32))
mrf.alpha = alpha
mrf.beta = beta
mrf.models = []
mrf.set_unaries(unary)
res = mrf.run(resize=False)
res = res[0, :, :]
res = np.where(mask_bb, res, -1)
# morphology
lbl_obj = 1
lbl_dom = 0
rad = 5
res_b = res == lbl_obj
res_b = skimor.binary_opening(res_b, selem=skimor.disk(rad))
res = np.where(res_b, lbl_obj, lbl_dom)
res = np.where(mask_bb, res, -1)
results.append(res.copy())
if show:
fig = plt.figure(figsize=(24, 14))
plt.subplot(141), plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
plt.subplot(142), plt.imshow(res, interpolation='nearest'), plt.title('result - %s' % t**s[i])
plt.subplot(143), plt.imshow(unary[:, 0, 0].reshape(im_orig.shape), 'gray', interpolation='nearest')
plt.title('unary #1')
plt.subplot(144), plt.imshow(unary[:, 0, 1].reshape(im_orig.shape), 'gray', interpolation='nearest')
plt.title('unary #2')
if save_fig:
figname = 'unary_%s_alpha_%i_rad_%i.png' % (t**s[i], alpha, rad)
fig.savefig(os.path.join(figdir, figname), dpi=100, bbox_inches='tight', pad_inches=0)
# plt.show()
# mrf.set_unaries(unaries)
# unaries =
# mrf.run()
# return mrf.labels_orig
fig = plt.figure(figsize=(24, 14))
n_imgs = 1 + len(saliencies)
plt.subplot(2, n_imgs, 1)
plt.imshow(im_orig, 'gray', interpolation='nearest'), plt.title('input')
for i in range(len(saliencies)):
plt.subplot(2, n_imgs, i + 2)
plt.imshow(saliencies[i], 'gray', interpolation='nearest')
plt.title(t**s[i])
for i, r in enumerate(results):
plt.subplot(2, n_imgs, i + n_imgs + 2)
plt.imshow(results[i], interpolation='nearest'), plt.title('result - %s' % t**s[i])
figname = 'unary_saliencies_alpha_%i_rad_%i.png' % (alpha, rad)
fig.savefig(os.path.join(figdir, figname), dpi=100, bbox_inches='tight', pad_inches=0)
plt.show()
def run_all(image,
mask,
pyr_scale=2.,
show=False,
show_now=True,
save_fig=False,
show_indi=False,
show_now_indi=True,
save_fig_indi=False,
verbose=True):
blob_types = [BLOB_DOG, BLOB_LOG, BLOB_DOH, BLOB_CV]
# blob_types = [BLOB_DOG, BLOB_CV]
n_types = len(blob_types)
survs = []
fig_dir = '/home/tomas/Dropbox/Work/Dizertace/figures/blobs/'
image, mask = tools.crop_to_bbox(image, mask)
image = tools.smoothing(image, sliceId=0)
for blob_type in blob_types:
# print 'Calculating %s ...' % blob_type,
surv_overall, survs_pyr, pyr_imgs, pyr_masks = run(
image,
mask,
pyr_scale=pyr_scale,
blob_type=blob_type,
show=show_indi,
show_now=show_now_indi,
save_fig=save_fig_indi,
verbose=verbose)
surv_layers = [s[0] for s in survs_pyr]
survs.append((surv_overall, surv_layers, blob_type))
# print 'done'
# survival image - overall
survs_overall = np.zeros(image.shape)
for surv_str in survs:
surv = surv_str[0]
if surv.shape != survs_overall.shape:
surv = cv2.resize(surv, survs_overall.shape[::-1])
survs_overall += surv
survs_overall /= float(n_types)
# survival image - layers
surv_layers = [] #survs[0][1]
for surv_str in survs:
layers = surv_str[1]
if len(surv_layers) == 0:
surv_layers = layers
else:
for i, surv_l in enumerate(layers):
surv_layers[i] += surv_l
surv_layers = [x / float(n_types) for x in surv_layers]
n_layers = len(surv_layers)
# VISUALIZATION ----------------------------------------------------------------------------------
if show or save_fig:
# survival image - overall
fig_surv_overall = plt.figure(figsize=(24, 14))
plt.subplot(121), plt.imshow(image, 'gray', interpolation='nearest')
plt.subplot(122), plt.imshow(survs_overall,
'jet',
interpolation='nearest')
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
# survival image - layers, number = 1, [layer1, layer2, ...]
fig_surv_layers = plt.figure(figsize=(24, 14))
for layer_id, survs_l in enumerate(surv_layers):
plt.subplot(1, n_layers, layer_id + 1)
plt.imshow(survs_l, 'jet', interpolation='nearest')
plt.title('layer #%i' % (layer_id + 1))
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
# survival image - overall jednotlivych metod [input, dog, log, hog, opencv]
fig_surv_methods = plt.figure(figsize=(24, 14))
plt.subplot(1, n_types + 1, 1)
plt.imshow(image, 'gray', interpolation='nearest')
plt.title('input')
for type_id, surv_str in enumerate(survs):
plt.subplot(1, n_types + 1, type_id + 2)
plt.imshow(surv_str[0], 'jet', interpolation='nearest')
plt.title(surv_str[2])
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax)
if save_fig:
fig_surv_overall.savefig(os.path.join(fig_dir, 'surv_overall.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_surv_layers.savefig(os.path.join(fig_dir, 'surv_layers.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
fig_surv_methods.savefig(os.path.join(fig_dir, 'surv_methods.png'),
dpi=100,
bbox_inches='tight',
pad_inches=0)
if show and show_now:
plt.show()
return survs_overall, survs
