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;
