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_segmentation(self, display=False):
# mask = self.data_term(find_all=False)
# mask = self.seeds.copy()
# strel = skimor.disk(2)
# ballM = np.zeros((2 * self.ball_r + 1, 2 * self.ball_r + 1, 2), dtype=np.int)
# ballM[:, :, 1] = np.tile(np.arange(-self.ball_r, self.ball_r + 1), [2 * self.ball_r + 1, 1])
# ballM[:, :, 0] = ballM[:, :, 1].conj().transpose()
#
# ballMOut = np.zeros((2 * self.ball_r_out + 1, 2 * self.ball_r_out + 1, 2), dtype=np.int)
# ballMOut[:, :, 1] = np.tile(np.arange(-self.ball_r_out, self.ball_r_out + 1), [2 * self.ball_r_out + 1, 1])
# ballMOut[:, :, 0] = ballMOut[:, :, 1].conj().transpose()
# self.segmentation = self.segmentInnerBoundary(self.energy, mask, ballM, strel, self.min_diff, self.alpha, display)
# self.membraneMask = skimor.binary_closing(self.membraneMask, strel)
if self.smoothing:
self.im = tools.smoothing(self.im, sigmaSpace=5, sigmaColor=5, sliceId=0)
if scale != 1:
self.im = tools.resize3D(self.im, self.scale, sliceId=0)
self.seeds = tools.resize3D(self.seeds, self.scale, sliceId=0)
self.segmentation = tools.resize3D(self.segmentation, self.scale, sliceId=0)
newbies = self.seeds.copy()
curr_it = 0
changed = True
while changed and curr_it < self.max_iters:
curr_it += 1
print 'iteration #%i/%i' % (curr_it, self.max_iters)
# mask, accepted, refused = self.iterationIB( im, mask, ballM, strel, minDiff, alpha )
mask_new, accepted, refused = self.iteration_IB(newbies)
# plt.figure()
# plt.subplot(121), plt.imshow(self.segmentation[0,...].copy(), 'gray')
# plt.subplot(122), plt.imshow(mask_new[0,...].copy(), 'gray')
# if (curr_it % 2) == 0:
# plt.show()
# newbies = mask_new - self.segmentation
# mask = mask_new
self.segmentation = mask_new
# self.newbies = np.zeros( self.newbies.shape, dtype=np.bool )
# self.newbies[accepted[0],accepted[1]] = True
if not accepted.any():
changed = False
for i, im in enumerate(self.segmentation):
self.segmentation[i,...] = skimor.binary_closing(im, np.ones((3, 3)))
# self.segmentation[i,...] = scindimor.binary_closing(self.segmentation, np.ones((3, 3, 3)))
# rescale the segmentation to original shape
if scale != 1:
tmp = np.zeros(self.orig_shape)
for i, im in enumerate(self.segmentation):
tmp[i,...] = cv2.resize(im.astype(np.uint8), (self.orig_shape[2], self.orig_shape[1]))
self.segmentation = tmp
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 blob_from_hist(data, show=False, show_now=True, min_int=0, max_int=255):
data = tools.windowing(data, sliceId=0)
data = tools.resize_ND(data, scale=0.1).astype(np.uint8)
data = tools.smoothing(data, sliceId=0)
min_interval = int((0 + 125) / 350. * 255)
max_interval = int((100 + 125) / 350. * 255)
mask = np.ones_like(data)
mask = np.where(data < 5, 0, mask)
mask = np.where(data > 250, 0, mask)
pts = data[np.nonzero(mask)]
hist, bins = skiexp.histogram(pts)
hist = tools.hist_smoothing(bins, hist)
# bins = bins / 255 * 350 - 125
hist_rec = np.zeros_like(hist)
hist_rec[min_interval:max_interval] = hist[min_interval:max_interval]
peak_idx = np.argmax(hist_rec)
hist_ind = bins[peak_idx]
hist_hu = hist_ind / 255 * 350 - 125
print 'hist ind: %.1f = %i HU' % (hist_ind, int(hist_hu))
if show:
plt.figure()
plt.plot(bins, hist, 'b-', lw=4)
plt.plot((min_interval, min_interval), (0, 1.2 * hist_rec.max()),
'm-',
lw=4)
plt.plot((max_interval, max_interval), (0, 1.2 * hist_rec.max()),
'm-',
lw=4)
plt.plot(hist_ind, hist[peak_idx], 'go', markersize=12)
img = data[21, ...]
hist_diff = abs(img.astype(np.int64) - hist_ind)
plt.figure()
plt.subplot(121), plt.imshow(img, 'gray',
interpolation='nearest'), plt.axis('off')
plt.subplot(122), plt.imshow(hist_diff,
'gray',
interpolation='nearest'), plt.axis('off')
if show_now:
plt.show()
return hist_ind
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 analyze_im_for_features(fn, show=True, show_now=True):
mask_fn = fn.replace('.%s' % (fn.split('.')[-1]), '_mask.%s' % (fn.split('.')[-1]))
im = cv2.imread(fn, 0)
ims = tools.smoothing(im, d=10, sigmaColor=50, sigmaSpace=10)
mask = cv2.imread(mask_fn, 0) > 0
pts = ims[np.nonzero(mask)]
# fuz.fcm(ims, mask=mask, n_clusters=2, show=True)
# color_clustering(ims, mask=mask, k=2)
hist, bins = skiexp.histogram(pts)
glcm = tools.graycomatrix_3D(ims, mask=mask)
# glcm *= glcm > 3
# glcm_p = glcm > (0.4 * glcm.max())
glcm_p = glcm > 2 * (glcm[np.nonzero(glcm)].mean())
# glcm_p = glcm > (np.median(glcm[np.nonzero(glcm)]))
glcm_pts = np.nonzero(glcm_p)
width = glcm_pts[1].max() - glcm_pts[1].min()
plt.figure()
plt.subplot(121), plt.imshow(glcm)
plt.subplot(122), plt.imshow(glcm_p, 'gray')
# plt.show()
mu, std = scista.norm.fit(pts.flatten())
# b = scista.norm.pdf(bins, mu, std)
# k = hist.max() / b.max()
# plt.figure()
# plt.plot(bins, hist, 'b-')
# plt.plot(bins, k * b, 'r-')
# plt.show()
if show:
plt.figure()
plt.suptitle('std=%.2f, width=%i' % (std, width))
plt.subplot(131), plt.imshow(skiseg.mark_boundaries(im, mask, color=(1,0,0), mode='thick'), 'gray', interpolation='nearest')
# plt.subplot(142), plt.imshow(mask, 'gray', interpolation='nearest')
plt.subplot(132), plt.plot(bins, hist, 'b-')
plt.xlim([0, 255])
plt.subplot(133), plt.imshow(glcm, interpolation='nearest')#, vmax=5 * glcm.mean())
if show_now:
plt.show()
return bins, hist, glcm
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 morph_hat_test(im):
im = tools.windowing(im)
im = tools.smoothing(im)
min_size = 11
max_size = 31
strels = []
for i in range(min_size, max_size + 1, 6):
strels.append(cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (i, i)))
tophats = tools.morph_hat(im, strels, show=True, show_now=False)
min_size = 41
max_size = 61
strels = []
for i in range(min_size, max_size + 1, 6):
strels.append(cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (i, i)))
blackhats = tools.morph_hat(im,
strels,
type='blackhat',
show=True,
show_now=True)
def run(im_in,
slice=None,
mask=None,
smoothing=True,
method='sfm',
max_iters=1000,
rad=10,
alpha=0.2,
scale=1.,
init_scale=0.5,
sigma=1,
smoothing_ls=1,
threshold=0.3,
balloon=1,
show=False,
show_now=True,
save_fig=False,
verbose=True):
im = im_in.copy()
if smoothing:
im = tools.smoothing(im, sigmaSpace=10, sigmaColor=10, sliceId=0)
# init_mask = initialize(im, dens_min=50, dens_max=200, show=True, show_now=False)[0,...]
if mask is None:
# mask = initialize_graycom(im, [1, 2], scale=1, show=show, show_now=show_now)
mask = tools.initialize_graycom(im,
slice,
distances=[
1,
],
scale=init_scale,
show=show,
show_now=show_now)
# else:
# im_init = im
if method == 'morphsnakes':
_debug(' Morph snakes ...', verbose, False)
im, mask, seg = morph_snakes(im,
mask,
scale=scale,
alpha=int(alpha),
sigma=sigma,
smoothing_ls=smoothing_ls,
threshold=threshold,
balloon=balloon,
max_iters=max_iters,
slice=slice,
show=show,
show_now=show_now)
_debug('done', verbose)
elif method in ['sfm', 'lls']:
_debug('SFM ...', verbose, False)
im, mask, seg = lankton_ls(im,
mask,
method=method,
max_iters=max_iters,
rad=rad,
alpha=alpha,
scale=scale,
slice=slice,
show=show,
show_now=show_now)
_debug('done', verbose)
return im, mask, seg
def blob_from_glcm(data, show=False, show_now=True, min_int=0, max_int=255):
data = tools.windowing(data, sliceId=0)
data_f = tools.resize_ND(data, scale=0.1).astype(np.uint8)
data_f = tools.smoothing(data_f, sliceId=0)
min_interval = int((0 + 125) / 350. * 255)
max_interval = int((100 + 125) / 350. * 255)
# min_int = 20
# max_int = 80
print 'calculating glcm ...',
glcm = tools.graycomatrix_3D(data_f)
print 'done'
glcm_rec = glcm.copy()
mask = np.zeros_like(glcm_rec)
mask[min_interval:max_interval, min_interval:max_interval] = 1
glcm_rec *= mask
max_r, max_c = np.unravel_index(np.argmax(glcm_rec), glcm_rec.shape)
glcm_ind = (max_r + max_c) / 2
glcm_hu = glcm_ind / 255 * 350 - 125
print 'glcm ind: %.1f = %i HU' % (glcm_ind, int(glcm_hu))
img = data[21, ...]
if show:
plt.figure()
plt.subplot(121), plt.imshow(glcm,
interpolation='nearest',
vmax=5 * glcm.mean())
plt.subplot(122), plt.imshow(glcm,
interpolation='nearest',
vmax=5 * glcm.mean())
plt.plot((min_interval, min_interval), (min_interval, max_interval),
'm-',
lw=5)
plt.plot((min_interval, max_interval), (max_interval, max_interval),
'm-',
lw=5)
plt.plot((max_interval, max_interval), (max_interval, min_interval),
'm-',
lw=5)
plt.plot((max_interval, min_interval), (min_interval, min_interval),
'm-',
lw=5)
plt.plot(max_c, max_r, 'wo', markersize=12)
plt.axis('image')
glcm_diff = abs(img.astype(np.int64) - glcm_ind)
plt.figure()
plt.subplot(121), plt.imshow(img, 'gray',
interpolation='nearest'), plt.axis('off')
plt.subplot(122), plt.imshow(glcm_diff,
'gray',
interpolation='nearest'), plt.axis('off')
if show_now:
plt.show()
return glcm_ind
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(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 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()
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
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_param_tuning_morphsnakes(im_in,
gt_mask,
slice_ind,
smoothing=True,
scale=0.5,
init_scale=0.5):
if smoothing:
im_in = tools.smoothing(im_in, sigmaSpace=10, sigmaColor=10, sliceId=0)
im = im_in.copy()
mask_init = tools.initialize_graycom(im,
slice,
distances=[
1,
],
scale=init_scale)
# parameters tuning ---------------------------------------------------------------
alpha_v = (10, 100, 500)
sigma_v = (1, 5)
threshold_v = (0.1, 0.5, 0.9)
balloon_v = (1, 2, 4)
method = 'morphsnakes'
# create workbook for saving the resulting pracision, recall and f-measure
workbook = xlsxwriter.Workbook(
'/home/tomas/Dropbox/Data/liver_segmentation/%s/%s.xlsx' %
(method, method))
worksheet = workbook.add_worksheet()
# Add a bold format to use to highlight cells.
bold = workbook.add_format({'bold': True})
# green = workbook.add_format({'bg_color': '#C6EFCE'})
worksheet.write(0, 0, 'F-MEASURE', bold)
worksheet.write(0, 1, 'PRECISION', bold)
worksheet.write(0, 2, 'RECALL', bold)
worksheet.write(0, 4, 'alpha', bold)
worksheet.write(0, 5, 'sigma', bold)
worksheet.write(0, 6, 'threshold', bold)
worksheet.write(0, 7, 'ballon', bold)
worksheet.write(0, 8, 'scale', bold)
worksheet.write(0, 9, 'scale_init', bold)
params_tune = []
for p in itertools.product(alpha_v, sigma_v, threshold_v, balloon_v):
params_tune.append(p)
# for i, (alpha, sigma, threshold, balloon) in enumerate(itertools.product(alpha_v, sigma_v, threshold_v, balloon_v)):
for i in range(len(params_tune)):
alpha, sigma, threshold, balloon = params_tune[i]
# threshold = 0.9
# balloon = 4
print '\n -- it #%i/%i --' % (i + 1, len(params_tune))
print 'Working with alpha=%i, sigma=%i, threshold=%.1f, balloon=%i' % (
alpha, sigma, threshold, balloon)
params = {
'alpha': alpha,
'sigma': sigma,
'smoothing_ls': 1,
'threshold': threshold,
'balloon': balloon,
'max_iters': 1000,
'scale': scale,
'init_scale': init_scale,
'smoothing': False,
'save_fig': False,
'show': True,
'show_now': False
}
im, mask, seg = run(im_in,
slice=slice_ind,
mask=mask_init,
method=method,
**params)
# print 'shapes 1: im={}, mask={}, seg={}'.format(im.shape, mask.shape, seg.shape)
if im.shape != im_in.shape:
im = tools.resize_ND(im, shape=im_in.shape)
if mask.shape != gt_mask.shape:
mask = tools.resize_ND(mask, shape=gt_mask.shape)
if seg.shape != gt_mask.shape:
seg = tools.resize_ND(seg, shape=gt_mask.shape)
# print 'shapes 2: im={}, mask={}, seg={}'.format(im.shape, mask.shape, seg.shape)
# calculating precision, recall and f_measure
precision, recall, f_measure = calc_statistics(seg, gt_mask)
# print 'shapes 3: im={}, mask={}, seg={}'.format(im.shape, mask.shape, seg.shape)
# saving data
datap = {'im': im, 'mask': mask, 'seg': seg, 'params': params}
dirname = '/home/tomas/Dropbox/Data/liver_segmentation/%s/' % method
dataname = '%s_al%i_si%i_th%s_ba%i.pklz' % (
method, alpha, sigma, str(threshold).replace('.', ''), balloon)
f = gzip.open(os.path.join(dirname, dataname), 'w')
pickle.dump(datap, f)
f.close()
# saving results
cols = [0, 1, 2, 4, 5, 6, 7, 8, 9]
items = (f_measure, precision, recall, alpha, sigma, threshold,
balloon, params['scale'], params['init_scale'])
for j, it in enumerate(items):
worksheet.write(i + 1, cols[j], it)
# creating visualization
fig = tools.visualize_seg(im,
seg,
mask,
slice=slice_ind,
title=method,
for_save=True,
show_now=False)
fname = '/home/tomas/Dropbox/Data/liver_segmentation/%s/%s_al%i_si%i_th%s_ba%i.png' \
% (method, method, alpha, sigma, str(threshold).replace('.', ''), balloon)
fig.savefig(fname)
plt.close('all')
workbook.close()
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(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(data, mask=None, save_fig=False, smoothing=False, return_all=False, show=False, show_now=True, verbose=True):
orig_shape = data.shape
data = skitra.rescale(data, 0.5, preserve_range=True).astype(np.uint8)
if data.ndim == 2:
data = np.expand_dims(data, 0)
if mask is not None:
mask = np.expand_dims(mask, 0)
# data = tools.smoothing_tv(data, weight=0.05, sliceId=0)
# data = tools.smoothing_gauss(data, sigma=1, sliceId=0)
if smoothing:
data = tools.smoothing(data, sigmaSpace=10, sigmaColor=10, sliceId=0)
# cc.hist2gmm(data, debug=verbose)
# cc.gmm_segmentation(data, debug=verbose)
# liver_rv = cc.estim_liver_prob_mod(data, show=False, show_now=show_now)
_, liver_rv = tools.dominant_class(data, dens_min=10, dens_max=245, show=False, show_now=False)
liver_prob = liver_rv.pdf(data)
# app = QtGui.QApplication(sys.argv)
# viewer = Viewer_3D(data)
# viewer.show()
# viewer2 = Viewer_3D(liver_prob, range=True)
# viewer2.show()
# sys.exit(app.exec_())
# plt.figure()
# plt.imshow(liver_prob[0,...], 'gray', interpolation='nearest')
# plt.show()
prob_c = 0.2
prob_c_2 = 0.01
seeds1 = liver_prob > (liver_prob.max() * prob_c)
seeds2 = liver_prob <= (np.median(liver_prob) * prob_c_2)
seeds = seeds1 + 2 * seeds2
# plt.figure()
# liver_prob = liver_prob[0,...]
# plt.subplot(231), plt.imshow(liver_prob <= liver_prob.mean(), 'gray', interpolation='nearest'), plt.title('mean')
# plt.subplot(232), plt.imshow(liver_prob <= liver_prob.min(), 'gray', interpolation='nearest'), plt.title('min')
# plt.subplot(233), plt.imshow(liver_prob <= np.median(liver_prob), 'gray', interpolation='nearest'), plt.title('median')
# plt.subplot(234), plt.imshow(liver_prob <= 0.5 * np.median(liver_prob), 'gray', interpolation='nearest'), plt.title('0.5 median')
# plt.subplot(235), plt.imshow(liver_prob <= 0, 'gray', interpolation='nearest'), plt.title('0.1 median')
# plt.show()
# plt.figure()
# plt.subplot(121), plt.imshow(liver_prob[0,...], 'gray', interpolation='nearest')
# plt.subplot(122), plt.imshow(seeds[0,...], 'gray', interpolation='nearest')
# plt.show()
gc = GrowCut(data, seeds, smooth_cell=False, enemies_T=0.7)
gc.run()
labs = gc.get_labeled_im().astype(np.uint8)
# labs2 = skifil.median(labs[0,...], selem=np.ones((3, 3)))
labs_f = scindifil.median_filter(labs, size=3)
# plt.figure()
# plt.subplot(121), plt.imshow(labs[0,...], 'jet', interpolation='nearest')
# plt.subplot(122), plt.imshow(labs_f[0,...], 'jet', interpolation='nearest')
# plt.show()
labs = labs_f
plt.figure()
plt.subplot(131), plt.imshow(data[0,...], 'gray', interpolation='nearest')
plt.subplot(132), plt.imshow(seeds[0,...], 'jet', interpolation='nearest')
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax, ticks=np.unique(seeds))
plt.subplot(133), plt.imshow(labs[0,...], 'jet', interpolation='nearest', vmin=0)
divider = make_axes_locatable(plt.gca())
cax = divider.append_axes('right', size='5%', pad=0.05)
plt.colorbar(cax=cax, ticks=np.unique(seeds))
plt.show()
def segmentation_stats(data_struc, scale=1, smoothing=True):
# fnames = load_data(datadir)
# fnames = ['/home/tomas/Dropbox/Data/medical/dataset/180_arterial-.pklz',]
# creating workbook
workbook = xlsxwriter.Workbook('/home/tomas/Dropbox/Data/liver_segmentation/final_alg/liver_seg_stats.xlsx')
worksheet = workbook.add_worksheet()
# Add a bold format to use to highlight cells.
bold = workbook.add_format({'bold': True})
# green = workbook.add_format({'bg_color': '#C6EFCE'})
col_gc_fmea = 3
col_gc_prec = 6
col_gc_rec = 9
col_ls_fmea = 4
col_ls_prec = 7
col_ls_rec = 10
cols_gc = (3, 6, 9)
cols_ls = (4, 7, 10)
start_row = 2
worksheet.write(0, 0, 'DATA', bold)
worksheet.write(0, 1, 'slice', bold)
worksheet.write(0, 3, 'F-MEASURE', bold)
worksheet.write(0, 6, 'PRECISION', bold)
worksheet.write(0, 9, 'RECALL', bold)
worksheet.write(1, col_gc_fmea, 'Grow Cut', bold)
worksheet.write(1, col_ls_fmea, 'Level Sets', bold)
worksheet.write(1, col_gc_prec, 'Grow Cut', bold)
worksheet.write(1, col_ls_prec, 'Level Sets', bold)
worksheet.write(1, col_gc_rec, 'Grow Cut', bold)
worksheet.write(1, col_ls_rec, 'Level Sets', bold)
# loading data
data_fnames = []
data_slices = []
for name, num in data_struc:
for i in num:
data_fnames.append(name)
data_slices.append(i)
n_imgs = len(data_fnames)
for i, (data_fname, slice) in enumerate(zip(data_fnames, data_slices)):
fname = data_fname.split('/')[-1].split('.')[0]
print '#%i/%i, %s [%i]: ' % (i + 1, n_imgs, fname, slice),
data, gt_mask, voxel_size = tools.load_pickle_data(data_fname)
data = data[slice,...]
gt_mask = gt_mask[slice,...]
print 'windowing ...',
data = tools.windowing(data)
shape_orig = data.shape
data_o = data.copy()
# plt.figure()
# plt.imshow(data, 'gray', vmin=0, vmax=255, interpolation='nearest')
# plt.show()
if scale != 1:
print 'resizing ...',
data = tools.resize_ND(data, scale=scale).astype(np.uint8)
if smoothing:
print 'smoothing ...',
data = tools.smoothing(data)
print 'gc ...',
blob, seg_gc = coarse_segmentation(data, clear_border=False, show=False, verbose=False)
print 'ls ...',
seg_ls = segmentation_refinement(data, blob, show=False, verbose=False)
if seg_gc.shape != gt_mask.shape:
seg_gc = tools.resize_ND(seg_gc, shape=shape_orig)
if seg_ls.shape != gt_mask.shape:
seg_ls = tools.resize_ND(seg_ls, shape=shape_orig)
# computing statistics
print 'stats ...',
precision_gc, recall_gc, f_measure_gc = ac.calc_statistics(blob, gt_mask)
precision_ls, recall_ls, f_measure_ls = ac.calc_statistics(seg_ls, gt_mask)
# writing statistics
print 'writing ...',
items = (f_measure_gc, precision_gc, recall_gc, f_measure_ls, precision_ls, recall_ls)
worksheet.write(start_row + i, 0, fname)
worksheet.write(start_row + i, 1, slice)
for it, col in zip(items, cols_gc + cols_ls):
worksheet.write(start_row + i, col, it)
print 'done'
fig = tools.visualize_seg(data_o, seg_ls, mask=seg_gc, title=fname, show_now=False, for_save=True)
out_fname = '/home/tomas/Dropbox/Data/liver_segmentation/final_alg/%s_sl_%i.png' % (fname, slice)
fig.savefig(out_fname)
plt.close('all')
print '\t\tfmea = %.3f -> %.3f, prec = %.3f -> %.3f, rec = %.3f -> %.3f' %\
(f_measure_gc, f_measure_ls, precision_gc, precision_ls, recall_gc, recall_ls)