def foreground_mask_morphsnakes(img): gI = morphsnakes.gborders(img, alpha=20000, sigma=1) mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-3) mgac.levelset = np.ones_like(img) mgac.levelset[:3,:] = 0 mgac.levelset[-3:,:] = 0 mgac.levelset[:,:3] = 0 mgac.levelset[:,-3:] = 0 num_iters = 1000 for i in xrange(num_iters): msnake.step() if np.sum(msnake.levelset - previous_levelset) < 3: break previous_levelset = msnake.levelset blob_labels, n_labels = label(msnake.levelset, neighbors=4, return_num=True) blob_props = regionprops(blob_labels + 1) largest_blob = np.argmax([p.area for p in blob_props]) mask = np.zeros_like(msnake.levelset, dtype=np.bool) mask[blob_labels == largest_blob] = 1 min_size = 40 mask = remove_small_objects(mask, min_size=min_size, connectivity=1, in_place=False) return mask
def foreground_mask_morphsnakes(img, levelset=None, max_iters=1000, scaling=1): # img = denoise_bilateral(img, win_size=5, sigma_range=1, sigma_spatial=7, bins=10000, mode='constant', cval=0) gI = morphsnakes.gborders(img, alpha=1000, sigma=3) msnake = morphsnakes.MorphGAC(gI, smoothing=1, threshold=.8, balloon=-1, scaling=scaling) if levelset is None: msnake.levelset = np.ones_like(img) msnake.levelset[:2, :] = 0 msnake.levelset[-2:, :] = 0 msnake.levelset[:, :2] = 0 msnake.levelset[:, -2:] = 0 else: msnake.levelset = levelset # min_iters = min(min_iters, max_iters) prev_levelset = levelset diffs = [] for i in xrange(max_iters): # print i # c = time.time() msnake.step() # print time.time() - c diff = np.count_nonzero(msnake.levelset - prev_levelset != 0) diffs.append(diff) if i > 10: q = np.abs(np.mean(diffs[-5:]) - np.mean(diffs[-10:-5])) if q < 2: break prev_levelset = msnake.levelset sys.stderr.write('iter %d\n' % i) mask = msnake.levelset.astype(np.bool) mask = remove_small_objects(mask, min_size=40) # previous_levelset = levelset # for i in xrange(max_iters): # msnake.step() # diff = np.count_nonzero(msnake.levelset - previous_levelset < 0) # print i, diff # if diff < diff_thresh and i > min_iters: # oscillate # break # previous_levelset = msnake.levelset rows, cols = np.where(mask) bbox = np.array([rows.min(), rows.max(), cols.min(), cols.max()]) return mask, bbox
def snake(self, imgBGR, imgMask): # Load the image. #imgcolor = imread("../training/color_1.jpg")/255.0 imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY) imgBGR = (imgBGR / 255.0).astype(np.float) imgGray = (imgGray / 255.0).astype(np.float) # g(I) gI = morphsnakes.gborders(imgGray, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=10, threshold=0.3, balloon=-1) _, imgMask = cv2.threshold(imgMask, 127, 255, cv2.THRESH_BINARY) mgac.levelset = imgMask # plot cv2.imshow('imgBGR', imgBGR) cv2.imshow('imgGray', imgGray) cv2.imshow('gI', gI) cv2.imshow('mgac.levelset', mgac.levelset) cv2.waitKey(0) # Visual evolution. plt.figure() b, g, r = cv2.split(imgBGR) imgRGB = cv2.merge([r, g, b]) morphsnakes.evolve_visual(mgac, num_iters=10, background=imgRGB) return mgac.levelset
def test_tian(): # Load the image. imgcolor = imread("../training/color_1.jpg") / 255.0 img = rgb2gray(imgcolor) # float in [0,1] # g(I) gI = morphsnakes.gborders(img, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=10, threshold=0.3, balloon=-1) #macwe = morphsnakes.MorphACWE(img, smoothing=3, lambda1=1, lambda2=10) mask = imread("../intermediate/mask1.jpg") _, mask = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY) mgac.levelset = mask #macwe.levelset = mask # plot cv2.imshow('imgcolor', imgcolor) cv2.imshow('img', img) cv2.imshow('gI', gI) cv2.imshow('mgac.levelset', mgac.levelset) cv2.waitKey(0) # Visual evolution. ppl.figure() morphsnakes.evolve_visual(mgac, num_iters=20, background=imgcolor) #morphsnakes.evolve_visual(macwe, num_iters=20, background=imgcolor) cv2.destroyAllWindows()
def test_mass(): dataPath = 'C:/Tomosynthesis/localtest/' fileName = '5131R-recon08_45-1.tif' outputPath = 'C:/Tomosynthesis/localtest/res/' im = ImageIO.imReader(dataPath,fileName, 'tif',2) # padding borarders ''' paddingrd = 10 bordares = ((paddingrd,paddingrd),(paddingrd,paddingrd)) paddingv = 10000 bordarevs = ((paddingv,paddingv),(paddingv,paddingv)) im = np.lib.pad(im.data[0], bordares, 'constant',constant_values = bordarevs) ''' eqimg = histEqualization.histEqualization(im.data[0], 16) denoised = AT_denoising.DenoisingAW(eqimg) denoised = AT_denoising.DenoisingAW(denoised) denoised = AT_denoising.DenoisingAW(denoised) img = AT_denoising.DenoisingAW(denoised) tiffLib.imsave(outputPath + 'denoised.tif',img) # g(I) gI = morphsnakes.gborders(img, alpha=1, sigma=8) tiffLib.imsave(outputPath + 'gI.tif',np.float32(gI)) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.035, balloon=-1) mgac.levelset = circle_levelset(img.shape, (img.shape[0]/2, img.shape[1]/2), 140, scalerow=0.75) # Visual evolution. ppl.figure() ls = morphsnakes.evolve_visual(mgac, num_iters=110, background=img) tiffLib.imsave(outputPath + 'ls.tif',np.float32(ls))
def active_snake(image_file, num_iters): #Parse image path and create result image path path, filename = os.path.split(image_file) print("processing image : {0} \n".format(str(filename))) #load the image and perform pyramid mean shift filtering to aid the thresholding step imgcolor = cv2.imread(image_file) img_gray = cv2.cvtColor(imgcolor, cv2.COLOR_BGR2GRAY) # Image binarization by applying otsu threshold thresh = threshold_otsu(img_gray) binary = img_gray > thresh # Extract convex hull of the binary image convexhull = convex_hull_image(invert(binary)) # label image regions label_image_convexhull = label(convexhull) # Measure properties of labeled image regions. regions = regionprops(label_image_convexhull) # center location of region y0, x0 = regions[0].centroid #print(y0,x0) print("Coordinates of centroid: {0} , {0} \n".format(y0, x0)) # axis length of region d_major = regions[0].major_axis_length d_minor = regions[0].minor_axis_length diameter = regions[0].equivalent_diameter minr, minc, maxr, maxc = regions[0].bbox d_bbox = max(maxr - minr, maxc - minc) radius = int(max(d_major, d_minor, d_bbox) / 2) + 20 print("Radius of convex hull region is: {0} \n".format(radius)) gI = morphsnakes.gborders(img_gray, alpha=5, sigma=1) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.24, balloon=-1) mgac.levelset = circle_levelset(img_gray.shape, (y0, x0), radius, scalerow=0.75) # Visual evolution. morphsnakes.evolve_visual(mgac, num_iters=num_iters, background=imgcolor) #define result path for simplified segmentation result result_img_path = save_path_ac + str(filename[0:-4]) + '.png' # suppose that img's dtype is 'float64' img_uint8 = img_as_ubyte(mgac.levelset) cv2.imwrite(result_img_path, img_uint8)
def test_pupil(): global p_up, p_down, p_left, p_right # Load the image. img_lvl = imread(filename) / 255.0 # g(I) gI = morphsnakes.gborders(img_lvl, alpha=2200, sigma=5.48) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac.levelset = circle_levelset(img_lvl.shape, (cy, cx), (max_t * 0.3)) # Visual evolution. ppl.figure() ij = morphsnakes.evolve_visual(mgac, num_iters=50, background=img_lvl) x_list = [] y_list = [] for i in range(w - 1): for j in range(h - 1): if ij[j][i] == 0: iris_bw[j][i] = (255, 0, 0) else: x_list.append(i) y_list.append(j) iris_bw[j][i] = (0, 0, 255) p_down = max(y_list) p_up = min(y_list) p_right = max(x_list) p_left = min(x_list)
def test_pupil(): global p_up,p_down,p_left,p_right # Load the image. img_lvl = imread(filename)/255.0 # g(I) gI = morphsnakes.gborders(img_lvl, alpha=2200, sigma=5.48) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac.levelset = circle_levelset(img_lvl.shape, (cy, cx), (max_t*0.3)) # Visual evolution. ppl.figure() ij = morphsnakes.evolve_visual(mgac, num_iters=50, background=img_lvl) x_list = [] y_list = [] for i in range(w-1): for j in range(h-1): if ij[j][i] == 0: iris_bw[j][i] = (255,0,0) else: x_list.append(i) y_list.append(j) iris_bw[j][i] = (0,0,255) p_down = max(y_list) p_up = min(y_list) p_right = max(x_list) p_left = min(x_list)
def test_GAC(cont, img, p_alpha=1000, p_sigma=6, p_threshold=0.47, p_balloon=1, p_smoothing=1, p_num_iters=70 ): gI = morphsnakes.gborders(img, alpha=p_alpha, sigma=p_sigma) mgac = morphsnakes.MorphGAC(gI, smoothing=p_smoothing, threshold=p_threshold, balloon=p_balloon) mgac.levelset = st.get_initial_point_lung(img, cont) ppl.figure() img = morphsnakes.evolve_visual(cont, mgac, num_iters=p_num_iters, background=img) return img
def test_gac(img, p_alpha=1000, p_sigma=4, p_threshold=0.45, p_balloon=1, p_smoothing=1, p_num_iters=70): from roi.startPointDoubleLung import get_initial_point_lung import morphsnakes # p_threshold = 0.50 #(Estabilidade prematura) ##################################################################### # AM: Definicao do criterio de parada baseado no gradiente # das fronteiras/bordas do objeto com função de suavizacao gaussiana # Onde: # - o parametro alpha funciona como um fator de peso para o gradiente. # Quanto maior for este valor maior a influencia da magnitude do # gradiente em regioes de diferentes contrastes # - o parametro sigma atua definindo a regiao de influencia da funcao # gaussiana, ou seja, define o desvio padrao. Quanto maior este valor, # maior sera a regiao de suavizacao da magnitude do gradiente, suavizando # o gradiente em regioes onde ha diferentes contrastes. ##################################################################### # g(I) levelset_zero, grad = get_initial_point_lung(img) g_i = morphsnakes.gborders(img, p_alpha, p_sigma) ee_3x3 = np.ones((4, 4), dtype=int) g_i = cv2.dilate(g_i, ee_3x3) g_i[g_i < 0.33] = 0.10 g_i[0.30 < g_i.all() < 0.50] = 0.34 ################### g_i = cv2.erode(g_i, ee_3x3) g_i = cv2.dilate(g_i, ee_3x3) # AM: Inicializacao do level-set em toda a dimensão da imagem # smoothing: scalar # Corresponde ao numero de repeticoes em que a suavizacao sera # aplicada a cada iteracao. Ou seja, a cada passo, serao aplicadas # smoothing vezes a funcao de suavizacao. Este procedimento e realizado # na funcao step da classe MorphGAC. Este representa o parametro µ. # # threshold : scalar # The threshold that determines which areas are affected # by the morphological balloon. This is the parameter θ. # balloon : scalar # The strength of the morphological balloon. This is the parameter ν. mgac = morphsnakes.MorphGAC(g_i, p_smoothing, p_threshold, p_balloon) # AM: Define a função phi inicial no domínio completo da imagem # (img.shape). Cujo centro é definido pelos pontos (iniPointY, iniPointX) # O raio da função phi inicial é definido último parametro, ex: 30. mgac.levelset = levelset_zero # AM: Visualiza a evolução da curva e inicializa o máximo de interações mgac.run(p_num_iters) return mgac.levelset
def sinus_right(x, y, img): # g(I) gI = morphsnakes.gborders(img, alpha=2000, sigma=1.67) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.1, balloon=2) mgac.levelset = circle_levelset(img.shape, (y, x), 20) # Visual evolution. ppl.figure() return morphsnakes.evolve_visual(mgac, num_iters=200, background=img)
def test_nodule(): # Load the image. img = imread("testimages/mama07ORI.bmp")[..., 0] / 255.0 # g(I) gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac.levelset = circle_levelset(img.shape, (100, 126), 20) # Visual evolution. ppl.figure() morphsnakes.evolve_visual(mgac, num_iters=45, background=img)
def test_nodule(): # Load the image. #img = imread("testimages/mama07ORI.bmp")[...,0]/255.0 #img_path = "testimages/CasoDD.bmp" img_path = "../../base de imagens/Ecocardiograma/Casos/Todos os Casos/" #img_name = "CasoID.bmp" img_name = "CasoQD.bmp" img_source = img_path + '/' + img_name img1 = imread(img_source)[..., 0] / 255.0 #img[img <= (30/255)] = 0; #img[img >= (120/255)] = 1; img2 = cv2.imread(img_source, 0)[..., 0] / 255.0 img = img2 print(type(img1)) print(type(img2)) cv2.waitKey(0) #img = imread("testimages/CasoDD.bmp")[...,0]/255.0 #img = imread("testimages/CasoDS.bmp")[...,0]/255.0 #img = imread("testimages/CasoBD.bmp")[...,0]/255.0 # g(I) #gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) gI = morphsnakes.gborders(img, alpha=1000, sigma=8) # Morphological GAC. Initialization of the level-set. #AM: mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.50, balloon=1) #mgac.levelset = circle_levelset(img.shape, (100, 126), 20) #CasoAs.bmp #mgac.levelset = circle_levelset(img.shape, (230, 330), 20) #CasoAs.bmp iniPoint = getInitialPoint(img_source) #iniPoint = getInitialPoint(img) iniPointX = iniPoint[0] iniPointY = iniPoint[1] print('-> iniPoint[0]: ' + str(iniPointX)) print('-> iniPoint[1]: ' + str(iniPointY)) mgac.levelset = circle_levelset(img.shape, (iniPointY, iniPointX), 30) # Visual evolution. ppl.figure() #morphsnakes.evolve_visual(mgac, num_iters=45, background=img) morphsnakes.evolve_visual(mgac, num_iters=50, background=img)
def test_morph_obj(): img = imread("testimages/twoObj.bmp") / 255.0 gI = morphsnakes.gborders(img, alpha=1000, sigma=1) # ppl.hist(gI, normed=True) mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.28, balloon=-1) mgac.levelset = circle_levelset(img.shape, (40, 40), 40) ppl.figure() return visual.evolve_visual(mgac, num_iters=40, background=img, save_every_iter=10)
def test_starfish(): # Load the image. imgcolor = imread("testimages/seastar2.png") / 255.0 img = rgb2gray(imgcolor) # g(I) gI = morphsnakes.gborders(img, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-1) mgac.levelset = circle_levelset(img.shape, (163, 137), 135, scalerow=0.75) # Visual evolution. ppl.figure() morphsnakes.evolve_visual(mgac, num_iters=110, background=imgcolor)
def test_1(): # Load the image. img = imread("output.jpg")[..., 0] / 255.0 # g(I) gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.41, balloon=1) mgac.levelset = circle_levelset(img.shape, (148, 200), 20) # Visual evolution. plt.figure() evolve_visual(mgac, img, num_iters=150, background=img) mpimg.imsave('crop.jpg', res)
def morph_snake(img, ROI, radius): #Input: Image to apply snake to as well as a region of interest and radius for the snake to initialize from and extend to #Output: Image of applied snake (including pixel values for mass outline) img1 = img / 255.0 # g(I) gI = morphsnakes.gborders(img1, alpha=1000, sigma=11) mgac = morphsnakes.MorphACWE(img1, smoothing=3, lambda1=1, lambda2=1) mgac.levelset = circle_levelset(img1.shape, ROI, radius) pylab.figure(figsize=(8, 6), dpi=400) return (morphsnakes.evolve_visual(mgac, num_iters=30, background=img1)) #110 pylab.show()
def ac_inwards(imdata,visulization = False): """Propagation from outside toward the center.""" # calculate gradient information (I) gI = morphsnakes.gborders(imdata, alpha=0.5, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.035, balloon=-1) mgac.levelset = circle_levelset(imdata.shape, (imdata.shape[0]/2, imdata.shape[1]/2), 110, scalerow=1.0) # Visual evolution. if visulization == True: matplotlib.pyplot.figure() ls = morphsnakes.evolve_visual(mgac,visulization, num_iters=80, background=imdata) return ls
def faz_level_set(img, poligono, it): gmin, gmax = 0.0, 1.0 fmin, fmax = img.min(), img.max() nimg = ((gmax - gmin) / (fmax - fmin)) * (img - fmin) + gmin gI = morphsnakes.gborders(nimg, alpha=1, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-1) mgac.levelset = poligono for i in xrange(it): mgac.step() yield mgac.levelset
def test_cord_GAC(img, prior, data_min, data_max): alpha = 1000 sigma = 3 smoothing = 5 threshold = 1 balloon = 1 alpha = int(alpha) sigma = float(sigma) gI = morphsnakes.gborders(img, alpha, sigma) smoothing = int(smoothing) threshold = float(threshold) balloon = int(balloon) mgac = morphsnakes.MorphGAC(gI, int(smoothing), float(threshold), int(balloon)) mgac.levelset = prior morphsnakes.evolve_visual(mgac, data_min, data_max, num_iters=45, background=img) return mgac.levelset
def ac_outwards(imdata,visulization = False): """Propagation from the center toward outside.""" imdata = np.max(imdata) - imdata # calculate gradient information (I) gI = morphsnakes.gborders(imdata, alpha=1.3, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.028, balloon=1) mgac.levelset = circle_levelset(imdata.shape, (imdata.shape[0]/2, imdata.shape[1]/2), 15) # Visual evolution. if visulization == True: matplotlib.pyplot.figure() ls = morphsnakes.evolve_visual(mgac, visulization, num_iters=130, background=imdata) return ls
def morph_snakes(data, mask, slice=None, scale=0.5, alpha=1000, sigma=1, smoothing_ls=1, threshold=0.3, balloon=1, max_iters=50, show=False, show_now=True): data_o = data.copy() mask_o = mask.copy() if scale != 1: # data = skitra.rescale(data, scale=scale, preserve_range=True).astype(np.uint8) # mask = skitra.rescale(mask, scale=scale, preserve_range=True).astype(np.bool) data = tools.resize3D(data, scale, sliceId=0) mask = tools.resize3D(mask, scale, sliceId=0) gI = morphsnakes.gborders(data, alpha=alpha, sigma=sigma) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=smoothing_ls, threshold=threshold, balloon=balloon) mgac.levelset = mask mgac.run(iterations=max_iters) seg = mgac.levelset if scale != 1: # data = tools.resize_ND(data, shape=orig_shape) # mask = tools.resize_ND(mask, shape=orig_shape) seg = tools.resize_ND(seg, shape=data_o.shape) if show: tools.visualize_seg(data_o, seg, mask_o, slice=slice, title='morph snakes', show_now=show_now) return data, mask, seg
def test_2(): for image_path in os.listdir(path): input_path = os.path.join(path, image_path) # Load the image. imgcolor = imread(input_path) / 255.0 img = rgb2gray(imgcolor) # g(I) gI = morphsnakes.gborders(img, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-1) mgac.levelset = circle_levelset(img.shape, (200, 250), 210, scalerow=0.75) # Visual evolution. plt.figure() res = evolve_visual(mgac, img, num_iters=320, background=imgcolor) fullpath = os.path.join(outPath, 'f' + image_path) mpimg.imsave(fullpath, res)
def snake_research(base_image, seed_image, per_size=0.25,smoothing=1, lambda1=1, lambda2=1): # the skimage snake implementation does not seems to be able to balloon # we try another implementation, maybe better, but pure research import sys sys.path.append('/home/remi/soft/morphsnakes') import morphsnakes from matplotlib import pyplot as ppl import time from skimage.transform import resize from PIL import Image from skimage.morphology import label # # Morphological ACWE. Initialization of the level-set. # macwe = morphsnakes.MorphACWE(base_image, smoothing=smoothing, lambda1=lambda1, lambda2=lambda2) # macwe.levelset = seed_image # plt.imshow(macwe.levelset) # # # Visual evolution. # ppl.figure() # last_levelset = morphsnakes.evolve_visual(macwe, num_iters=10, background=jac) # return last_levelset down_sampled_jac = resize_image(base_image, per_size) gI = morphsnakes.gborders(down_sampled_jac, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=3, threshold=0.8, balloon=1.5) markers = label(seed_image) mgac.levelset = resize_image(markers>0, per_size) # Visual evolution. ppl.figure() start_time = time.time() last_levelset = morphsnakes.evolve_visual(mgac, num_iters=50, background=down_sampled_jac ) interval = time.time() - start_time print('Total time in seconds:', interval) return last_levelset
def test_GAC(img, p_alpha=1000, p_auto_ini=True, p_x_ini=0, p_y_ini=0, p_sigma=6, p_threshold=0.47, p_balloon=1, p_smoothing=1, p_num_iters=70, p_raio=30): #p_threshold = 0.50 #(Estabilidade prematura) ##################################################################### # AM: Definicao do criterio de parada baseado no gradiente # das fronteiras/bordas do objeto com função de suavizacao gaussiana # Onde: # - o parametro alpha funciona como um fator de peso para o gradiente. # Quanto maior for este valor maior a influencia da magnitude do # gradiente em regioes de diferentes contrastes # - o parametro sigma atua definindo a regiao de influencia da funcao # gaussiana, ou seja, define o desvio padrao. Quanto maior este valor, # maior sera a regiao de suavizacao da magnitude do gradiente, suavizando # o gradiente em regioes onde ha diferentes contrastes. ##################################################################### # g(I) # gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) gI = morphsnakes.gborders(img, alpha=p_alpha, sigma=p_sigma) #ppl.title("Resultado da função gI") #ppl.imshow(gI) #return ##################################################################### # AM: Inicializacao do level-set em toda a dimensão da imagem # smoothing: scalar # Corresponde ao numero de repeticoes em que a suavizacao sera # aplicada a cada iteracao. Ou seja, a cada passo, serao aplicadas # smoothing vezes a funcao de suavizacao. Este procedimento e realizado # na funcao step da classe MorphGAC. Este representa o parametro µ. # # threshold : scalar # The threshold that determines which areas are affected # by the morphological balloon. This is the parameter θ. # balloon : scalar # The strength of the morphological balloon. This is the parameter ν. ################################################################## #AM: mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac = morphsnakes.MorphGAC(gI, smoothing=p_smoothing, threshold=p_threshold, balloon=p_balloon) ################################################################## # AM: Calcula o ponto de inicialização da curva inicial do level-set ################################################################## if p_auto_ini: iniPoint = getInitialPoint(img_source) iniPointX = iniPoint[0] iniPointY = iniPoint[1] else: iniPointX = p_x_ini iniPointY = p_y_ini #print('-> iniPoint[0]: '+ str(iniPointX)) #print('-> iniPoint[1]: '+ str(iniPointY)) ################################################################## # AM: Define a função phi inicial no domínio completo da imagem # (img.shape). Cujo centro é definido pelos pontos (iniPointY, iniPointX) # O raio da função phi inicial é definido último parametro, ex: 30. # !!TODO!! -> Definir melhor o funcinamento desta função a luz do artigo ################################################################## mgac.levelset = getInitialPointLung(img) #mgac.levelset = circle_levelset(img.shape, (iniPointY, iniPointX), p_raio) ################################################################## # AM: Visualiza a evolução da curva e inicializa o máximo de interações ################################################################## ppl.figure() morphsnakes.evolve_visual(mgac, num_iters=p_num_iters, background=img)
def MICOS(fileNAME): tic = time.clock() selfz =0 selfz1 = 0 selfz2 = 0 selfrotD = -90 imgObj2= nib.load(str(fileNAME)) imgObj1 = imgObj2 im = imgObj2 selfaffine2 = imgObj2.get_affine() selfheaderdtype = imgObj2.get_data_dtype() selfPSx = imgObj1.get_header()['pixdim'][1] selfPSy = imgObj1.get_header()['pixdim'][2] selfPSz = imgObj1.get_header()['pixdim'][3] (x,y,z) = orx.aff2axcodes(selfaffine2) selfOrx = x selfOry = y selfOrz = z ornt = orx.axcodes2ornt((x,y,z)) refOrnt = orx.axcodes2ornt(('R','S','A')) #was 'R', 'A', 'S' newOrnt = orx.ornt_transform(ornt,refOrnt) selfornt = ornt selfrefOrnt = refOrnt selfimg_data2 = imgObj2.get_data() selfimg_data2 = orx.apply_orientation(selfimg_data2,newOrnt) selfimg_data2 = np.fliplr(np.rot90(selfimg_data2,1)) im_data = selfimg_data2 [x_si,y_si,z_si] = np.shape(im_data) #do 99% norm to 1000 im_data = np.array(im_data,dtype='float') im_data = im_data * 1000/np.percentile(im_data,99) #print np.shape(im_data) initialSeg = im_data.copy() * 0 #begin user roi drawing... #go from middle up... for i in xrange(np.round(z_si/2),z_si,3): img = (im_data[:,:,i]) # show the image if i > np.round(z_si/2): plt.figure(figsize=(ROI1.figwidth,ROI1.figheight)) plt.imshow(img,cmap='gray') plt.colorbar() plt.title("outline one kidney, slice = " + str(i)) # let user draw first ROI ROI1 = polydraw(roicolor='r') #let user draw first ROI # show the image with the first ROI plt.figure(figsize=(ROI1.figwidth,ROI1.figheight)) plt.imshow(img,cmap='gray') plt.colorbar() ROI1.displayROI() plt.title("outline other kidney, slice = " + str(i)) # let user draw second ROI ROI2 = polydraw(roicolor='b') #let user draw ROI initialSeg[:,:,i] = ROI1.getMask(img) + ROI2.getMask(img) #go from middle up... for i in xrange(np.round(z_si/2)-1,0,-3): img = (im_data[:,:,i]) # show the image plt.figure(figsize=(ROI1.figwidth,ROI1.figheight)) plt.imshow(img,cmap='gray') plt.colorbar() plt.title("outline one kidney, slice = " + str(i)) # let user draw first ROI ROI1 = polydraw(roicolor='r') #let user draw first ROI # show the image with the first ROI plt.figure(figsize=(ROI1.figwidth,ROI1.figheight)) plt.imshow(img,cmap='gray') plt.colorbar() ROI1.displayROI() plt.title("outline other kidney, slice = " + str(i)) # let user draw second ROI ROI2 = polydraw(roicolor='b') #let user draw ROI initialSeg[:,:,i] = ROI1.getMask(img) + ROI2.getMask(img) toc = time.clock() #save out drawn polygon aff = selfaffine2 outImage = deepcopy(initialSeg)#np.rot90(np.fliplr(self.segImg),-1) [x_si,y_si,z_si] = np.shape(outImage) #print np.shape(outImage) #This method works (for fastsegs)... but need more robust #for i in range(0,z_si): # outImage[:,:,i] = np.rot90(self.segImg[:,:,z_si-1-i],-1) #try new method (more robust to header and affine mix-ups) ornt = orx.axcodes2ornt((selfOrx,selfOry,selfOrz)) refOrnt = orx.axcodes2ornt(('R','S','A')) newOrnt = orx.ornt_transform(refOrnt,ornt) #reversed these outImage= orx.apply_orientation(np.rot90(np.fliplr(outImage),-1),newOrnt) #outImage = orx.apply_orientation(outImage,newOrnt) #outImage = np.rot90(np.fliplr(outImage),-1) #print np.shape(outImage) #outImage = np.array(outImage,dtype=selfheaderdtype) new_image = nib.Nifti1Image(outImage,aff) nib.save(new_image,fileNAME[:-7]+'_polygon_MICOS.nii.gz') # Dilate and fill in missing slices initialSeg = dilation(initialSeg,iterations = 1) finalSeg = initialSeg.copy() * 0 # now try convex hull method instead to better approximate missing slices (previous method is above) # This works but way too long. Also, would likely need to do object finding first, so compute # Convex hull for each kidney separately. while 0: xlist,ylist,zlist = find_3D_object_voxel_list(initialSeg) voxlist = np.zeros(shape=(np.shape(xlist)[0],3),dtype='int16') voxlist[:,0] = xlist voxlist[:,1] = ylist voxlist[:,2] = zlist tri = dtri(voxlist) # construct full voxel list xxlist,yylist,zzlist = find_3D_object_voxel_list((initialSeg+1)>0) fullvoxlist = np.zeros(shape=(np.shape(xxlist)[0],3),dtype='int16') fullvoxlist[:,0] = xxlist fullvoxlist[:,1] = yylist fullvoxlist[:,2] = zzlist finalSeg = np.array(in_hull(fullvoxlist,tri),dtype=float) finalSeg = np.reshape(finalSeg,(x_si,y_si,z_si)) # Now do gaussian blur of polygon to smooth initialSeg = (filt.gaussian_filter(initialSeg.copy()*255,sigma=[3,3,1])) > 100 #Begin optimized method... for i in xrange(0,z_si): img = (im_data[:,:,i]) if np.max(initialSeg[:,:,i]>0): mgac = [] gI = msnake.gborders(img,alpha=1E5,sigma=3.0) # increasing sigma allows more changes in contour mgac = msnake.MorphGAC(gI,smoothing=3,threshold=0.01,balloon=0.0) #was 2.5 mgac.levelset = initialSeg[:,:,i]>0.5 for ijk123 in xrange(100): mgac.step() finalSeg[:,:,i] = mgac.levelset #print i # Now do gaussian blur and threshold to finalize segmentation... finalSeg = (filt.gaussian_filter(finalSeg.copy()*255,sigma=[3,3,1])) > 100 #using this helps with single slice errors of the active contour # Try adding now narrow band sobel/watershed technique. for i in xrange(0,z_si): img = (im_data[:,:,i]) segslice = finalSeg[:,:,i] if np.max(finalSeg[:,:,i]>0): erodeimg = erosion(segslice.copy(),iterations=1) dilateimg = dilation(segslice.copy(),iterations=1) seeds = img * 0 seeds[:] = 1 seeds[dilateimg>0] = 0 seeds[erodeimg>0] = 2 sobelFilt = sobel(np.array(img.copy(),dtype='int16')) mgac = watershed(sobelFilt,seeds)>1 finalSeg[:,:,i] = mgac>0 #save out segmentation aff = selfaffine2 outImage = deepcopy(finalSeg)#np.rot90(np.fliplr(self.segImg),-1) outImage = np.array(outImage,dtype='float') [x_si,y_si,z_si] = np.shape(outImage) #This method works (for fastsegs)... but need more robust #for i in range(0,z_si): # outImage[:,:,i] = np.rot90(self.segImg[:,:,z_si-1-i],-1) #try new method (more robust to header and affine mix-ups) ornt = orx.axcodes2ornt((selfOrx,selfOry,selfOrz)) refOrnt = orx.axcodes2ornt(('R','S','A')) newOrnt = orx.ornt_transform(refOrnt,ornt) #reversed these outImage= orx.apply_orientation(np.rot90(np.fliplr(outImage),-1),newOrnt) #outImage = orx.apply_orientation(outImage,newOrnt) #outImage = np.rot90(np.fliplr(outImage),-1) new_image = nib.Nifti1Image(outImage,aff) nib.save(new_image,fileNAME[:-7]+'_FASTseg_MICOS.nii.gz') print 'time = ' print toc - tic return (fileNAME[:-7]+'_FASTseg_MICOS.nii.gz')
def foreground_mask_morphsnakes(img, num_iters=1000): gI = morphsnakes.gborders(img, alpha=20000, sigma=1) msnake = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-3) msnake.levelset = np.ones_like(img) msnake.levelset[:3, :] = 0 msnake.levelset[-3:, :] = 0 msnake.levelset[:, :3] = 0 msnake.levelset[:, -3:] = 0 for i in xrange(num_iters): msnake.step() if i > 0: if i > 1: previous_diff = diff diff = np.count_nonzero(msnake.levelset - previous_levelset) # print i, diff if i > 1: if diff == previous_diff and diff < 40 and i > 500: # oscillate break previous_levelset = msnake.levelset # plt.figure() # morphsnakes.evolve_visual(msnake, num_iters=600, background=img) blob_labels, n_labels = label(msnake.levelset, neighbors=4, return_num=True, background=0) blob_props = regionprops(blob_labels + 1) all_areas = [p.area for p in blob_props] indices = np.argsort(all_areas)[::-1] largest_blob = indices[0] n_sections = 1 if len(all_areas) > 1: second_blob = indices[1] if all_areas[second_blob] / all_areas[largest_blob] > 0.6: print 'two sections in this image' n_sections = 2 masks = [] for sec_i in range(n_sections): mask = np.zeros_like(msnake.levelset, dtype=np.bool) mask[blob_labels == indices[sec_i]] = 1 min_size = 40 mask = remove_small_objects(mask, min_size=min_size, connectivity=1, in_place=False) masks.append(mask) return masks
seeds = np.array(labels.copy()*0,dtype = 'uint8') seeds[labelsD==1] = 1 seeds[labelsE==1] = 2 seeds[labelsE*labelsD] = 0 seeds[labelsE2==1] = 1 sobelFilt = sobel(mrdata[:,:,i]) #output[:,:,i] = watershed(mrdata[:,:,i],seeds)>1 # _WS4 used this output[:,:,i] = watershed(sobelFilt,seeds)>1 #_withSobel used this #Add active contour while 0: mgac = [] gI = msnake.gborders(mrdata[:,:,i],alpha=1E5,sigma=1.0) # increasing sigma allows more changes in contour mgac = msnake.MorphGAC(gI,smoothing=3,threshold=0.01,balloon=0.0) mgac.levelset = output[:,:,i]>0.5 for ijk123 in xrange(3): mgac.step() output[:,:,i] = mgac.levelset else: output[:,:,i] = output[:,:,i] * 0 #print i #_WS4 used this finalSeg = np.array(output,dtype='float') finalSeg = (filt.gaussian_filter(finalSeg*255,sigma=[3,3,1])) > 100 output = mrdata.copy() * 0
def ac( NAME, priorSeg, followUpScan, followUpSegName, alpha=1e5, sigma=3, smoothing=3, threshold=0.01, balloon=1.0, iters=45, ): "Perform active contour on initial warped follow-up segmentation (to finalize segmentation)." print "Performing active contour finalization of follow-up segmentation..." input_fixed = followUpScan gray = nib.load(input_fixed) graydata = gray.get_data() # do 99% norm to 1000 origDATA = np.array(graydata, dtype=float) origDATA = origDATA * 1000 / np.percentile(origDATA, 99) input_seg = NAME + "/" + os.path.basename(priorSeg[:-7]) + "0to1.nii.gz" seg = nib.load(input_seg) segdata = seg.get_data() affine = seg.get_affine() new_image_preAC = nib.Nifti1Image(segdata, affine) nib.save(new_image_preAC, followUpSegName[:-7] + "_preAC.nii.gz") img = segdata > 0.2 [L, M, N] = np.shape(img) # Active Contour 2D finalseg2 = img.copy() * 0 for n in range(0, N): mgac = [] img2 = origDATA[:, :, n] gI = msnake.gborders(img2, alpha, sigma) # Morphological GAC. Initialization of the level-set. mgac = msnake.MorphGAC(gI, smoothing, threshold, balloon) mgac.levelset = img[:, :, n] > 0.2 for ijk123 in xrange(iters): # num iterations mgac.step() finalseg2[:, :, n] = mgac.levelset # Light filtering finalSeg = (gaussian_filter(finalseg2.copy() * 255, sigma=[3, 3, 1])) > 100 im_data = origDATA.copy() # Add now narrow band sobel/watershed technique. for i in xrange(0, N): img = im_data[:, :, i] segslice = finalSeg[:, :, i] if np.max(finalSeg[:, :, i] > 0): erodeimg = erosion(segslice.copy(), iterations=1) dilateimg = dilation(segslice.copy(), iterations=1) seeds = img * 0 seeds[:] = 1 seeds[dilateimg > 0] = 0 seeds[erodeimg > 0] = 2 sobelFilt = sobel(np.array(img.copy(), dtype="int16")) mgac = watershed(sobelFilt, seeds) > 1 finalSeg[:, :, i] = mgac > 0 # Write the final output affine = seg.get_affine() image1 = np.uint8(finalSeg) new_image = nib.Nifti1Image(image1, affine) nib.save(new_image, followUpSegName)
import sys sys.path.append('/home/yuncong/morphsnakes') import morphsnakes import numpy as np from skimage.io import imread from matplotlib import pyplot as plt from skimage.color import rgb2gray, rgb2hsv imgcolor = imread("/home/yuncong/DavidData2015tifFlat/CC35_x0.3125/CC35_x0.3125_0281.tif")/255. img = rgb2gray(imgcolor) gI = morphsnakes.gborders(img, alpha=20000, sigma=1) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-3) mgac.levelset = np.ones_like(img) mgac.levelset[:3,:] = 0 mgac.levelset[-3:,:] = 0 mgac.levelset[:,:3] = 0 mgac.levelset[:,-3:] = 0 # Visual evolution. plt.figure() morphsnakes.evolve_visual(mgac, num_iters=500, background=imgcolor)
sig = 5.3 alph = 2500 smooth = 1 thres = 0.395 ball = 1.6#1.48 iter = 250 dst = cv2.GaussianBlur(imbw,(5,5),0) dst = imbw img = dst/255.0 gI = morphsnakes.gborders(img, alpha=alph, sigma=sig) # cv2.imshow("Cost", gI) mgac = morphsnakes.MorphGAC(gI, smoothing=smooth, threshold=thres, balloon=ball) # mgac.levelset = circle_levelset(img.shape, (300,160), 15) mgac.levelset = circle_levelset(img.shape, (302,175), 15) # macwe = morphsnakes.MorphACWE(img, smoothing=1, lambda1=1, lambda2=5) # macwe.levelset = circle_levelset(img.shape, (255, 255), 25) mask1, edges = morphsnakes.evolve(mgac, num_iters=iter, animate=True, background=dst) # cv2.waitKey(0) mgac = morphsnakes.MorphGAC(gI, smoothing=smooth, threshold=thres, balloon=ball) mgac.levelset = circle_levelset(img.shape, (300,353), 15)
def image_process(img_last_rgb, img_curr_rgb): global bb_x1, bb_y1, bb_x2, bb_y2 global prev_bbx_x1, prev_bbx_y1, prev_bbx_x2, prev_bbx_y2 global inputImg1, inputImg2, input_img_prev, input_img_curr global flag_predict_use_SURF, flag_predict_use_Dense flag_predict_use_SURF = False flag_predict_use_Dense = False flag_whole_imag_test = False # Get BBox Ground Truth by groudtruth #print index row = ground_truth_array[index] print('bbox_gt:', row) if len(img_curr_rgb.shape) < 3: inputImg1 = cv2.cvtColor(img_last_rgb, cv.CV_GRAY2RGB) inputImg2 = cv2.cvtColor(img_curr_rgb, cv.CV_GRAY2RGB) input_img_prev = img_last_rgb.copy() input_img_curr = img_curr_rgb.copy() else: inputImg1 = img_last_rgb.copy() inputImg2 = img_curr_rgb.copy() input_img_prev = cv2.cvtColor(img_last_rgb, cv2.COLOR_BGR2GRAY) input_img_curr = cv2.cvtColor(img_curr_rgb, cv2.COLOR_BGR2GRAY) if (flag_whole_imag_test == False): # Save All BBox file row to tmp variables tmp_x1 = int(row[0]) tmp_y1 = int(row[1]) tmp_x2 = int(row[2]) tmp_y2 = int(row[3]) tmp_x3 = int(row[4]) tmp_y3 = int(row[5]) tmp_x4 = int(row[6]) tmp_y4 = int(row[7]) print('eight variables', tmp_x1, tmp_y1, tmp_x2, tmp_y2, tmp_x3, tmp_y3, tmp_x4, tmp_y4) # Selecet the top-left and bottom-right points, # due to the different foramt(sequence) of the bbox file min_x = min(tmp_x1, tmp_x2, tmp_x3, tmp_x4) min_y = min(tmp_y1, tmp_y2, tmp_y3, tmp_y4) max_x = max(tmp_x1, tmp_x2, tmp_x3, tmp_x4) max_y = max(tmp_y1, tmp_y2, tmp_y3, tmp_y4) print('minX minY maxX maxY', min_x, min_y, max_x, max_y) bb_x1_gt = min_x bb_y1_gt = min_y bb_x2_gt = max_x bb_y2_gt = max_y width_gt = max_y - min_y height_gt = max_x - min_x else: img_rows, img_cols = input_img_prev.shape bb_x1_gt = 1 bb_y1_gt = 1 bb_x2_gt = img_rows bb_y2_gt = img_cols width_gt = img_cols height_gt = img_rows print('width_gt height_gt', width_gt, height_gt) print('bb_x1_gt, bb_y1_gt, bb_x2_gt, bb_y2_gt', bb_x1_gt, bb_y1_gt, bb_x2_gt, bb_y2_gt) # Choose current use bbox if ((flag_predict_use_SURF == False) and (flag_predict_use_Dense == False)) or (index < 2): bb_x1 = bb_x1_gt bb_y1 = bb_y1_gt bb_x2 = bb_x2_gt bb_y2 = bb_y2_gt width = width_gt height = height_gt else: bb_x1 = prev_bbx_x1 bb_y1 = prev_bbx_y1 bb_x2 = prev_bbx_x2 bb_y2 = prev_bbx_y2 width = bb_y2 - bb_y1 height = bb_x2 - bb_x1 #print ('bb', bb_x1, bb_y1, bb_x2, bb_y2) img_curr_rgb_clone = img_curr_rgb.copy() cv2.rectangle(img_curr_rgb_clone, (bb_x1, bb_y1), (bb_x2, bb_y2), (0, 255, 0), 2) # Draw ground truth bbx # create a CLAHE object (Arguments are optional). clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) cl1 = clahe.apply(input_img_prev) input_img_prev = cl1.copy() clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) cl2 = clahe.apply(input_img_curr) input_img_curr = cl2.copy() # ------ Save BBox (x1, y1, x2, y2) with (h, w) img_rows, img_cols = input_img_prev.shape scale = 0.2 bbox_x1 = int(max(0, bb_x1 - scale * height)) #refPt[0][1] bbox_x2 = int(min(bb_x2 + scale * height, img_cols)) #refPt[1][1] bbox_y1 = int(max(0, bb_y1 - scale * width)) #refPt[0][0] bbox_y2 = int(min(bb_y2 + scale * width, img_rows)) #refPt[1][0] refPt = np.empty([2, 2]) refPt[0][1] = bbox_x1 refPt[1][1] = bbox_x2 refPt[0][0] = bbox_y1 refPt[1][0] = bbox_y2 # print bbox_x1, bbox_x2, bbox_y1, bbox_y2 height = bbox_x2 - bbox_x1 width = bbox_y2 - bbox_y1 print('bbox', bbox_x1, bbox_x2, bbox_y1, bbox_y2) print('bbox_width*height', width, height) cv2.rectangle(img_curr_rgb_clone, (bbox_x1, bbox_y1), (bbox_x2, bbox_y2), (0, 0, 255), 2) str_temp = 'Ground Truth' cv2.putText(img_curr_rgb_clone, str_temp, (10, 30), font, 0.5, (0, 255, 0), 2) str_temp = '| BBox Extend' cv2.putText(img_curr_rgb_clone, str_temp, (130, 30), font, 0.5, (0, 0, 255), 2) cv2.namedWindow('Ground Truth', cv2.WINDOW_AUTOSIZE) total_frame = len(ground_truth_array) current_frame_str = 'Frame: ' current_frame_str += str(index) current_frame_str += ' / ' current_frame_str += str(total_frame) print('img_rows', img_rows) cv2.putText(img_curr_rgb_clone, current_frame_str, (10, int(img_rows - 20)), font, 0.5, (255, 255, 255), 2) cv2.imshow('Ground Truth', img_curr_rgb_clone) cv2.moveWindow('Ground Truth', 100, 100) #cv2.waitKey(0) #print bbox_x1, bbox_y1, bbox_x2, bbox_y2, height, width # ------------------ Active Countour ----------- #-----Splitting the LAB image to different channels------------------------- img = img_curr_rgb.copy() lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) l, a, b = cv2.split(lab) # cv2.imshow('l_channel', l) # cv2.imshow('a_channel', a) # cv2.imshow('b_channel', b) #-----Applying CLAHE to L-channel------------------------------------------- clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8)) cl = clahe.apply(l) cv2.imshow('CLAHE output', cl) #-----Merge the CLAHE enhanced L-channel with the a and b channel----------- limg = cv2.merge((cl, a, b)) img_countour = input_img_curr.copy() center_y = (bbox_y2 - bbox_y1) / 2 center_x = (bbox_x2 - bbox_x1) / 2 img_countour = img_countour[bbox_y1:bbox_y2, bbox_x1:bbox_x2] # img_countour = img_countour[center_y-10:center_y+10, center_x-10:center_x+10] # img_countour = exposure.equalize_hist(img_countour) img_countour_roi = img_countour.copy() cv2.namedWindow(' ROI', cv2.WINDOW_AUTOSIZE) cv2.imshow(' ROI', img_countour_roi) kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (30, 30)) img_closing = cv2.morphologyEx(img_countour_roi, cv2.MORPH_CLOSE, kernel) img_opening = cv2.morphologyEx(img_countour_roi, cv2.MORPH_OPEN, kernel) img_minus = img_closing - img_opening cv2.namedWindow('Active_Countour_Minus', cv2.WINDOW_AUTOSIZE) cv2.imshow('Active_Countour_Minus', img_minus) # g(I) # gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) gI = morphsnakes.gborders(img_minus, alpha=500, sigma=1) cv2.namedWindow('GI', cv2.WINDOW_AUTOSIZE) cv2.imshow('GI', gI) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-1) # mgac.levelset = circle_levelset(img.shape, (159, 103), 50, scalerow=0.1) # rect_level_set = np.zeros(img_countour.shape) # # rect_level_set[243-10:276-10, 228+10:366+10] = 1 [img_height, img_width] = img_countour.shape rect_level_set[3:img_height - 3, 3:img_width - 3] = 0.5 # rect_level_set[center_y-10:center_y+10, center_x-10:center_x+10] = 1 mgac.levelset = rect_level_set start_time = time.time() return_level_set = morphsnakes.evolve_visual(mgac, num_iters=10, background=img_countour) delta_time_contour = (time.time() - start_time) print("--- %s seconds ---" % delta_time_contour) # print('return_level_set',return_level_set) print('return_level_set', return_level_set.shape) img_draw_contour = img_countour.copy() # --- Using python plot show ---- # ppl.figure(1) # fig = ppl.gcf() # fig.clf() # gs = gridspec.GridSpec(1, 2, width_ratios=[1, 1]) # ax1 = ppl.subplot(1,2,2) # ax1.imshow(img_draw_contour, cmap=ppl.cm.gray) # ax1.contour(return_level_set, [0.5], colors='r') # fig.canvas.draw() # ax2 = ppl.subplot(1,2,1) # ax2.imshow(input_img_curr, cmap=ppl.cm.gray) # ppl.pause(0.05) return_level_set = cv2.resize(return_level_set, (160, 160), interpolation=cv2.INTER_CUBIC) contours, hierarchy = cv2.findContours( cv2.convertScaleAbs(return_level_set), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) img_curr_rgb_draw = img_curr_rgb.copy() img_curr_rgb_draw = img_curr_rgb_draw[bbox_y1:bbox_y2, bbox_x1:bbox_x2] img_curr_rgb_draw = cv2.resize(img_curr_rgb_draw, (160, 160), interpolation=cv2.INTER_CUBIC) cv2.drawContours(img_curr_rgb_draw, contours, -1, (0, 0, 250), 2) cv2.namedWindow('contour', cv2.WINDOW_NORMAL) cv2.imshow('contour', img_curr_rgb_draw) cv2.resizeWindow('contour', 160, 160) file_name = image_folder file_name += '_Contour_' file_name += str(index).zfill(3) file_name += '.jpg' cv2.imwrite(os.path.join(dirname, file_name), img_curr_rgb_draw) time_consume[index] = delta_time_contour
def foreground_mask_morphsnakes_slide(img, levelset=None, max_iters=1000, num_section_per_slide=5, min_iters=300): # ls = pickle.load(open('/tmp/levelset.pkl', 'rb')) # img = denoise_bilateral(img, win_size=5, sigma_range=1, sigma_spatial=3, bins=10000, mode='constant', cval=0) # plt.imshow(img) # plt.show() gI = morphsnakes.gborders(img, alpha=15000, sigma=1) msnake = morphsnakes.MorphGAC(gI, smoothing=2, threshold=0.3, balloon=-3) if levelset is None: msnake.levelset = np.ones_like(img) msnake.levelset[:2, :] = 0 msnake.levelset[-2:, :] = 0 msnake.levelset[:, :2] = 0 msnake.levelset[:, -2:] = 0 else: msnake.levelset = levelset # for i in xrange(max_iters): # msnake.step() # if i > 0: # diff = np.count_nonzero(msnake.levelset - previous_levelset < 0) # print i, diff # if diff < 40 and i > min_iters: # oscillate # break # previous_levelset = msnake.levelset plt.figure() morphsnakes.evolve_visual(msnake, num_iters=max_iters, background=img) blob_labels, n_labels = label(msnake.levelset, neighbors=4, return_num=True, background=0) # pickle.dump(msnake.levelset, open('/tmp/levelset.pkl', 'wb')) # blob_labels, n_labels = label(ls, neighbors=4, return_num=True, background=0) blob_props = regionprops(blob_labels + 1) all_areas = np.array([p.area for p in blob_props]) all_centers = np.array([p.centroid for p in blob_props]) all_bboxes = np.array([p.bbox for p in blob_props]) indices = np.argsort(all_areas)[::-1] largest_area = all_areas[indices[:2]].mean() valid = np.where(all_areas > largest_area * .45)[0] valid = valid[np.argsort(all_centers[valid, 1])] centers_x = all_centers[valid, 1] centers_y = all_centers[valid, 0] print 'valid', valid height, width = img.shape[:2] if len(valid) > num_section_per_slide: indices_close = np.where(np.diff(centers_x) < width * .1)[0] print indices_close ups = [] downs = [] if len(indices_close) > 0: for i in range(len(valid)): if i - 1 in indices_close: continue elif i in indices_close: if centers_y[i] > height * .5: ups.append(valid[i + 1]) downs.append(valid[i]) else: ups.append(valid[i]) downs.append(valid[i + 1]) else: if centers_y[i] > height * .5: ups.append(-1) downs.append(valid[i]) else: ups.append(valid[i]) downs.append(-1) print ups, downs arrangement = np.r_[ups, downs] elif len(valid) < num_section_per_slide: snap_to_columns = (np.round( (centers_x / width + 0.1) * num_section_per_slide) - 1).astype( np.int) print 'snap_to_columns', snap_to_columns arrangement = -1 * np.ones((num_section_per_slide, ), dtype=np.int) arrangement[snap_to_columns] = valid else: arrangement = valid print 'arrangement', arrangement bboxes = [] masks = [] for i, j in enumerate(arrangement): if j == -1: continue minr, minc, maxr, maxc = all_bboxes[j] bboxes.append(all_bboxes[j]) mask = np.zeros_like(img, dtype=np.bool) mask[blob_labels == j] = 1 section_mask = mask[minr:maxr + 1, minc:maxc + 1] masks.append(section_mask) return masks, bboxes, arrangement > -1
def test_GAC(img, p_alpha = 1000, p_auto_ini=True, p_x_ini=0, p_y_ini=0, p_sigma = 6, p_threshold = 0.47, p_balloon = 1, p_smoothing = 1, p_num_iters = 70, p_raio = 30, img_name=""): #p_threshold = 0.50 #(Estabilidade prematura) ##################################################################### # AM: Definicao do criterio de parada baseado no gradiente # das fronteiras/bordas do objeto com função de suavizacao gaussiana # Onde: # - o parametro alpha funciona como um fator de peso para o gradiente. # Quanto maior for este valor maior a influencia da magnitude do # gradiente em regioes de diferentes contrastes # - o parametro sigma atua definindo a regiao de influencia da funcao # gaussiana, ou seja, define o desvio padrao. Quanto maior este valor, # maior sera a regiao de suavizacao da magnitude do gradiente, suavizando # o gradiente em regioes onde ha diferentes contrastes. ##################################################################### # gI = morphsnakes.gborders(img, alpha=1000, sigma=5.48) levelset_zero,grad = getInitialPointLung(img); gI = morphsnakes.gborders(img, alpha=p_alpha, sigma=p_sigma) ee = np.array([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) ee_1 = np.eye(3) ee_2 = np.array([[1.0, 0, 0], [0, 1, 0],[0, 0, 1]]) ee_3 = np.array([[0, 0, 1], [0, 1, 0],[1, 0, 0]]) ee2 = np.array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]) ee3 = np.array([[1, 1],[1, 1], [1, 1],[1, 1],[1, 1]]) gI = cv2.dilate(gI, ee) ##################################################################### # AM: Fuzzy Frontier Detector - Fuzzy Adjust ##################################################################### param_lambda = 0.30 param_kappa = 0.50 gI[gI<0.33] = 0.10 # g(I) function gI[gI.all()>param_lambda and gI.all()<param_kappa] = 0.34 # g(I) fuzzy gI = cv2.erode(gI, ee) # local Min gI = cv2.dilate(gI, ee)# local Max ##################################################################### # AM: Inicializacao do level-set em toda a dimensão da imagem # smoothing: scalar # Corresponde ao numero de repeticoes em que a suavizacao sera # aplicada a cada iteracao. Ou seja, a cada passo, serao aplicadas # smoothing vezes a funcao de suavizacao. Este procedimento e realizado # na funcao step da classe MorphGAC. Este representa o parametro µ. # # threshold : scalar # The threshold that determines which areas are affected # by the morphological balloon. This is the parameter θ. # balloon : scalar # The strength of the morphological balloon. This is the parameter ν. ################################################################## #AM: mgac = morphsnakes.MorphGAC(gI, smoothing=1, threshold=0.31, balloon=1) mgac = morphsnakes.MorphGAC(gI, smoothing=p_smoothing, threshold=p_threshold, balloon=p_balloon) ################################################################## # AM: Calcula o ponto de inicialização da curva inicial do level-set ################################################################## if p_auto_ini : iniPoint = getInitialPoint(img_source) iniPointX = iniPoint[0] iniPointY = iniPoint[1] else: iniPointX = p_x_ini iniPointY = p_y_ini #print('-> iniPoint[0]: '+ str(iniPointX)) #print('-> iniPoint[1]: '+ str(iniPointY)) ################################################################## # AM: Define a função phi inicial no domínio completo da imagem # (img.shape). Cujo centro é definido pelos pontos (iniPointY, iniPointX) # O raio da função phi inicial é definido último parametro, ex: 30. # !!TODO!! -> Definir melhor o funcinamento desta função a luz do artigo ################################################################## mgac.levelset = levelset_zero #mgac.levelset, img_norm = getInitialPointLung(img); #mgac.levelset = circle_levelset(img.shape, (iniPointY, iniPointX), p_raio) ################################################################## # AM: Visualiza a evolução da curva e inicializa o máximo de interações ################################################################## ppl.figure() morphsnakes.evolve_visual(mgac, num_iters=p_num_iters, background=img) ################################################################## # AM: Executa sem visualizar a evoluçao da curva ################################################################## #mgac.run(iterations=p_num_iters) return mgac.levelset;
def snake(self, imgBGR, imgMask): # Load the image. #imgcolor = imread("../training/color_1.jpg")/255.0 imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY) imgBGR = (imgBGR/255.0).astype(np.float) imgGray =(imgGray/255.0).astype(np.float) # g(I) gI = morphsnakes.gborders(imgGray, alpha=1000, sigma=2) # Morphological GAC. Initialization of the level-set. mgac = morphsnakes.MorphGAC(gI, smoothing=10, threshold=0.3, balloon=-1) _, imgMask = cv2.threshold(imgMask,127,255,cv2.THRESH_BINARY) mgac.levelset = imgMask # plot cv2.imshow('imgBGR', imgBGR) cv2.imshow('imgGray', imgGray) cv2.imshow('gI', gI) cv2.imshow('mgac.levelset', mgac.levelset) cv2.waitKey(0) # Visual evolution. plt.figure() b,g,r = cv2.split(imgBGR) imgRGB = cv2.merge([r,g,b]) morphsnakes.evolve_visual(mgac, num_iters=10, background=imgRGB) return mgac.levelset