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_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 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_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_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 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 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 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 perform_ac(parameters): """ Return the shape resulting of morphosnake operation on image I using image S as an initialisation m : label of the cell to work on daughters : list of the daughters of cell m (to keep track when working in parallel) bb : bounding boxe of m I : intensity image to perform active contours on (SpatialImage) S : segmented image to perform active contours from (SpatialImage, must contain the label m) """ m, daughters, bb, I, S, MorphosnakeIterations, NIterations, DeltaVoxels = parameters import os from scipy import ndimage as nd import morphsnakes cell_num = m Sb = nd.binary_erosion(S != cell_num, iterations=MorphosnakeIterations, border_value=1) #[:,:,sl] image_input = 'tmp_' + str(cell_num) + '.inr' gradient_output = 'tmp_out_' + str(cell_num) + '.inr' imsave(image_input, I) gradient_norm(image_input, gradient_output) gI = imread(gradient_output) os.system('rm -f ' + image_input + ' ' + gradient_output) gI = 1. / np.sqrt(1 + 100 * gI) macwe = morphsnakes.MorphGAC(gI, smoothing=3, threshold=1, balloon=1) macwe.levelset = Sb bef = np.ones_like(Sb) from copy import deepcopy for i in xrange(NIterations): beff = deepcopy(bef) bef = deepcopy(macwe.levelset) macwe.step() if np.sum(bef != macwe.levelset) < DeltaVoxels or np.sum( beff != macwe.levelset) < DeltaVoxels: break out = macwe.levelset tmp = nd.binary_fill_holes(out) cell_out = (out.astype(np.bool) ^ tmp) return m, daughters, bb, cell_out
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 test_confocal3d(img): if False: macwe = morphsnakes.MorphGAC(img, smoothing=1, threshold=0.3, balloon=-1) else: macwe = morphsnakes.MorphACWE(img, smoothing=1, lambda1=1, lambda2=2) macwe.levelset = circle_levelset(img.shape, (30, 50, 80), 25) if True: # Visual evolution. morphsnakes.evolve_visual3d(macwe, num_iters=200) else: fig = ppl.figure(frameon=False) for i in range(100): macwe.step() fd = macwe.levelset ppl.imshow(np.max(img, axis=2), cmap='gray') ppl.imshow(np.max(fd[:, :, :], axis=2), cmap='jet', alpha=0.3) ppl.show() ppl.pause(.1) ppl.draw()
def segment(img, center=[0, 0], radius=20, visual=lambda x: None, iterations=200, smoothing=6, threshold=0.65): # Initialization of the level-set. init_ls = skimage.segmentation.circle_level_set(img.shape, center, radius) if USE_MS: morph = ms.MorphGAC(init_ls, img, smoothing, threshold, 1) prev_ls = init_ls for i in range(iterations): morph.step() visual(morph.levelset) if i % 100 == 0: if (prev_ls != morph.levelset).sum() < 50: break prev_ls = np.copy(morph.levelset) if i == 1000: logging.debug('Did not converge.') else: logging.debug('Converged after %d iterations.', i) segmentation = morph.levelset else: segmentation = skimage.segmentation.morphological_geodesic_active_contour( img, iterations=iterations, init_level_set=init_ls, smoothing=smoothing, threshold=threshold, balloon=1, iter_callback=visual) return segmentation
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)
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
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 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(original, 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_count=0): ############## Fazer função em outra biblioteca para isso ######################### original_resized = cv2.resize(original, (0, 0), fx=0.2, fy=0.2) img = cv2.resize(img, (0, 0), fx=0.2, fy=0.2) processedImage = img #cv2.imshow("resized_image", processedImage) #cv2.waitKey(0) #if (len(img.shape) <= 2): #processedImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #hist = cv2.calcHist([img],[0],None,[256],[0,256]) #cv2.imshow("Histograma", hist) #cv2.waitKey(0) #processedImage = cv2.equalizeHist(processedImage) ''' cv2.imshow("Imagem equalizada", processedImage) cv2.waitKey(1) ''' #else: #processedImage = img for i in range(1): processedImage = cv2.GaussianBlur(processedImage, (3, 3), 0) processedImage = cv2.medianBlur(processedImage, 3) #cv2.imshow('Blur', processedImage) #cv2.waitKey(0) ret, binaryImage = cv2.threshold(processedImage, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) #cv2.imshow('Threshold', processedImage) #cv2.waitKey(0) #==================== Mask ================= mask_img = cv2.imread('PH2Dataset/mask.png', 0) mask_img = cv2.resize(mask_img, (0, 0), fx=0.4, fy=0.4) mask_img = cv2.resize(mask_img, (binaryImage.shape[1], binaryImage.shape[0])) binaryImage = mask_img & binaryImage #cv2.imshow('Result', result) #cv2.waitKey(0) #============================================ kernel = np.ones((5, 5), np.uint8) binaryImage = cv2.dilate(binaryImage, kernel, iterations=1) #cv2.imshow('Dilate', processedImage) #v2.waitKey(1) # Fazer uma função que determine os limites de threshold individualmente para cada imagem (medidas estatísticas) #return #################################################################################### ##################################################################### # 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=600, sigma=3) #gI = morphsnakes.gborders(processedImage, alpha=p_alpha, sigma=p_sigma) gI = morphsnakes.gborders2(binaryImage) #plt.title("Resultado da função gI") #plt.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 # Determina o limiar de atuacao da forca balao. Eh o parametro θ. # balloon : scalar # Determina a intensidade/velocidade da forca balao. Eh o parametro ν. ################################################################## #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 ################################################################## #mgac.levelset = SetInitialPoint(img) img = img & mask_img mean = int(np.sum(img) / np.alen(img)) for row in range(img.shape[0]): for col in range(img.shape[1]): if img[row, col] == 0: img[row, col] = abs((img[row, col] - mean) / 2) parzen_window = ParzenWindow(img, inf_thresh=0, sup_thresh=100, h=0.6, n_points=50) mgac.levelset = parzen_window.segmentation() cv2.imshow('Original', img) data = mgac.levelset data = data / data.max() data = data * 255 images.append(~data.astype(np.uint8)) cv2.imshow('Segmentation', ~data.astype(np.uint8)) cv2.waitKey(0)
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) mask2, edges = morphsnakes.evolve(mgac, num_iters=iter, animate=True, background=dst)
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 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;