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