def foreground_separation(img_thre):
contour_ref = img_thre.copy()
img_thre = closing(img_thre, disk(1))
img_thre = -img_thre + 1
img_thre = closing(img_thre, disk(2))
img_thre = -img_thre + 1
img_thre = closing(img_thre, disk(20))
img_thre = -img_thre + 1
img_thre = closing(img_thre, disk(10))
img_thre = -img_thre + 1
img_thre = area_closing(img_thre, 20000, connectivity=2)
contour_ref = contour_ref.astype(float)
img_thre = img_thre.astype(float)
img_binary = MorphGAC(-contour_ref + 1,
5,
-img_thre + 1,
smoothing=1,
balloon=0.8,
threshold=0.5)
img_binary = area_closing(img_binary, 1000, connectivity=2)
return -img_binary + 1
def method_3(mask_img: "Image", down_factor=4) -> "NDArray[np.uint8]":
"""Downsample =>
Area_opening followed by area_closing (Remove local maxima and minima) =>
Upsample"""
width, height = mask_img.width, mask_img.height
# Downsample the image
mask_arr = np.array(
mask_img.resize((width // down_factor, height // down_factor), Image.NEAREST))
del mask_img
print('Finish downsampling')
# Apply area_opening to remove local maxima with area < 200000 px
mask_arr = morphology.area_opening(mask_arr, area_threshold=320000 // down_factor**2)
print('Finish area_opening')
# Apply area_closing to remove local minima with area < 200000 px
mask_arr = morphology.area_closing(mask_arr, area_threshold=320000 // down_factor**2)
print('Finish area_closing')
# Upsample the output
mask_arr = np.array(Image.fromarray(mask_arr).resize((width, height), Image.NEAREST))
print('Finish upsampling')
return mask_arr
def removeSmallComponents(image: np.ndarray, component_min_area: int = 100):
''' Remove the components smaller than a defined area.
Input(s):
image: segmented map image
component_min_area: threshold below which the components should be removed
Output(s):
image: grayscale cleaned segmented map image
'''
def labelsToGray(orig_gray: np.ndarray, orig_labels: np.ndarray, labeled: np.ndarray):
new_gray = np.zeros(orig_gray.shape)
for shade in np.unique(orig_gray):
shade_labels = np.unique(orig_labels[orig_gray == shade])
shade_labels = shade_labels[shade_labels != 0]
for shade_label in shade_labels:
new_gray[labeled == shade_label] = shade
return new_gray
if len(image.shape) > 2:
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
else:
gray = image
labels = findAllComponents(gray)
cleared = remove_small_objects(labels, 100)
closed = area_closing(dilation(dilation(cleared)))
labels[cleared == 0] = closed[cleared == 0]
new_gray = labelsToGray(gray, cleared, labels)
return new_gray
def method_6(mask_img: "Image", down_factor=4) -> "NDArray[np.uint8]":
"""Downsample => Area_opening (Remove local maxima) =>
Swap index of GM and WM => Area_opening => Swap index back =>
Area_closing => Morphological opening => Upsample"""
# pylint: disable=invalid-name
def swap_GM_WM(arr):
"""Swap GM and WM in arr (swaps index 1 and index 2)"""
arr_1 = (arr == 1)
arr[arr == 2] = 1
arr[arr_1] = 2
del arr_1
return arr
# pylint: enable=invalid-name
width, height = mask_img.width, mask_img.height
area_threshold_prop = 0.05
area_threshold = int(area_threshold_prop * width * height // down_factor**2)
# Downsample the image
mask_arr = np.array(
mask_img.resize((width // down_factor, height // down_factor), Image.NEAREST))
del mask_img
print('Finish downsampling')
# Apply area_opening to remove local maxima with area < 20000 px
mask_arr = morphology.area_opening(mask_arr, area_threshold=320000 // down_factor**2)
print('Finish area_opening #1')
# Swap index of GM and WM
mask_arr = swap_GM_WM(mask_arr)
print('Finish swapping index')
# Apply area_opening to remove local maxima with area < 20000 px
mask_arr = morphology.area_opening(mask_arr, area_threshold=320000 // down_factor**2)
print('Finish area_opening #2')
# Swap index back
mask_arr = swap_GM_WM(mask_arr)
print('Finish swapping index back')
# Apply area_closing to remove local minima with area < 12500 px
mask_arr = morphology.area_closing(mask_arr, area_threshold=200000 // down_factor**2)
print('Finish area_closing')
# Apply remove_small_objects to remove tissue residue with area < 0.05 * width * height
tissue_arr = morphology.remove_small_objects(mask_arr > 0, min_size=area_threshold,
connectivity=2)
mask_arr[np.invert(tissue_arr)] = 0
del tissue_arr
print('Finish remove_small_objects')
# Apply opening with disk-shaped kernel (r=8) to smooth boundary
mask_arr = morphology.opening(mask_arr, selem=morphology.disk(radius=32 // down_factor))
print('Finish morphological opening')
# Upsample the output
mask_arr = np.array(Image.fromarray(mask_arr).resize((width, height), Image.NEAREST))
print('Finish upsampling')
return mask_arr
def NuclSegmentation(frames, channel, file_name):
"""
NuclSegmentation function
Segments cell nuclei
"""
if not os.path.exists("output/" + str(file_name) + "/segmentation/nucl"):
os.makedirs("output/" + str(file_name) + "/segmentation/nucl")
frame_shape = frames[0].shape
model = unet.get_unet(frame_shape[0], frame_shape[1], channel)
model.compile(optimizer=optimizer, loss=loss, metrics=[metrics])
model.load_weights(nucl_model)
# if contrast.lower()=="yes" :
#
# bright_frames = []
#
# for frame in frames :
#
# frame = ContrastNormalized(frame, percentile)
#
# bright_frames.append(frame)
#
# bright_frames=np_.asanyarray(bright_frames)
# bright_frames = np_.expand_dims(bright_frames, axis=3)
# prediction = model.predict(bright_frames)
#elif contrast.lower()=="no":
frames = np_.asanyarray(frames)
frames = np_.expand_dims(frames, axis=3)
prediction = model.predict(frames)
segmentation_org = []
segmentation_dil = []
segmentation_ero = []
thr = 0.9
for idx, pred in enumerate(prediction):
pred = (pred.reshape(512, 512) > thr).astype(np_.uint8)
pred_org = mp_.area_closing(pred)
segmentation_org.append(pred_org)
pred_dil = mp_.binary_dilation(pred_org, mp_.disk(2))
segmentation_dil.append(pred_dil)
pred_ero = mp_.binary_dilation(pred_org, mp_.disk(2))
segmentation_ero.append(pred_ero)
# pl_.figure()
# pl_.imshow(pred,cmap="gray")
labeled_sgm = mp_.label(pred_org, connectivity=1)
pl_.imsave("output/" + str(file_name) + "/segmentation/nucl/frame" +
str(idx) + ".jpg",
labeled_sgm,
cmap="gray")
return segmentation_org, segmentation_dil, segmentation_ero
def eliminarPontosPretos(
img): #função para eliminar os pontos pretos da imagem
axs[1].set_title('Imagem com pontos pretos retirados')
axs[1].set_axis_off() #tira o eixo x e y das imagem que fica na coluna 1
fechamento = morphology.area_closing(
img, 64, 1
) #faz o fechamento(kernel/vizinhança=[4,4]) apenas com fig de tamanho <= 64(número de pixels) com conectividade 1
axs[1].imshow(greyToRGB(fechamento), cmap='gray')
def main():
name = sys.argv[1].split('/')[-1].split('.')[0]
print("Segmenting image: {}".format(name))
image_og = color.rgb2gray(plt.imread(data_path))
image_og = plt.imread(data_path)
seg = regiongrow(data_path)
counter = 0
for i in seg:
for j in i:
if (j == True):
counter += 1
print("Segmented area dimension: {}".format(counter))
print("Processing...")
seg = 255 * seg
seg = morphology.dilation(seg, selem=morphology.disk(6))
seg = morphology.area_closing(seg, area_threshold=3000)
seg = morphology.dilation(seg, selem=morphology.disk(4))
seg = morphology.area_closing(seg, area_threshold=400)
seg = morphology.opening(seg, selem=morphology.disk(16))
seg = morphology.binary_erosion(seg, selem=morphology.disk(4))
seg = (1 / 255) * seg
res = np.copy(image_og)
res[seg == False] = 255
res = filters.gaussian(res, sigma=1.5)
thresh = filters.threshold_sauvola(res)
res = (res > thresh) * 1
res = morphology.area_closing(res, area_threshold=100) #64
res = morphology.binary_erosion(res)
# Apply eroded mask again to delete borders from Sauvola
seg = morphology.binary_erosion(seg, selem=morphology.disk(24))
res[seg == False] = 255
# show_comparison(image, seg)
# save_comparison(image_og, res, name)
# save_image(res, name)
# print("Done.\n")
return res
def areaclosing():
global filterimage
tree = morphology.area_closing(img,
area_threshold=64,
connectivity=1,
parent=None,
tree_traverser=None)
filterimage = tree
io.imshow(tree)
io.show()
def method_2(mask_arr: "NDArray[np.uint8]") -> "NDArray[np.uint8]":
"""Area_opening followed by area_closing (Remove local maxima and minima)"""
# Apply area_opening to remove local maxima with area < 200000 px
mask_arr = morphology.area_opening(mask_arr, area_threshold=200000)
print('Finish area_opening')
# Apply area_closing to remove local minima with area < 200000 px
mask_arr = morphology.area_closing(mask_arr, area_threshold=200000)
print('Finish area_closing')
return mask_arr
def area_closing():
image = read_image_return_scikit()
closed = morphology.area_closing(image,area_threshold=1, connectivity=1)
fig, (ax0, ax1) = plt.subplots(nrows=1, ncols=2, figsize=(8, 3),
sharex=True, sharey=True)
ax0.imshow(image, cmap=plt.cm.gray)
ax0.axis('off')
ax1.imshow(closed, cmap=plt.cm.gray)
ax1.axis('off')
plt.show()
def hitOrMissMagenta(img):
axs[0][1].set_title('Imagem original binária com inversão dos pixels')
axs[1][0].set_title('Elemento Estruturante de cor magenta')
axs[1][1].set_title(
'Localização do Hit or Miss para objeto de cor magenta')
axs[0][1].set_axis_off(
) #tira o eixo x e y das imagem que fica na linha 0 coluna 1
axs[1][0].set_axis_off(
) #tira o eixo x e y das imagem que fica na linha 1 coluna 0
axs[1][1].set_axis_off(
) #tira o eixo x e y das imagem que fica na linha 1 coluna 1
fechamento = morphology.area_closing(img, 64, 1) #retira todos os pontos
linha, coluna = fechamento.shape
for i in range(linha):
for j in range(coluna):
if (
fechamento[i][j] != 88
): #seta os pixels da fig de cor não magenta(na escala de cinza) para branco
fechamento[i][j] = 255
thresh = threshold_otsu(
img
) #auxilia na transformação da img na escola de cinza para binária// threshold automatico
binary = invert(img > thresh).astype(
np.int
) #tranforma a imagem que tem a figura magenta em binaria(true/false)
axs[0][1].imshow(
binary,
cmap='gray') #mostra a imagem original binaria(com pixels invertidos)
thresh2 = threshold_otsu(
fechamento
) #auxilia na transformação da img na escala de cinza para binária
binary2 = invert(fechamento > thresh2).astype(
np.int
) #tranforma a imagem que tem a figura magenta em binaria(true/false)
binary2 = binary2[~np.all(binary2 == 0,
axis=1)] #deleta as linhas que tem somente zero
idx = np.argwhere(
np.all(binary2[..., :] == 0,
axis=0)) #procura por tds colunas que tem somente zero
binary2 = np.delete(binary2, idx,
axis=1) #deleta tds colunas que tem somente zero
axs[1][0].imshow(
binary2,
cmap='gray') #mostra o elementro estruturante na forma binária
binary2[
binary2 ==
0] = 2 #pixels de n° zero sao setados para 2(dont care) não precisa ser comparado
hitOrMiss = mh.hitmiss(
binary, binary2
) #operação hit or miss para objeto de cor magenta (retorna o ponto central do objeto localizado)
axs[1][1].imshow(hitOrMiss, cmap='gray')
def CellSegmentation(frames, channel, file_name):
if not os.path.exists("output/" + str(file_name) + "/segmentation/cell"):
os.makedirs("output/" + str(file_name) + "/segmentation/cell")
frame_shape = frames[0].shape
model = unet.get_unet(frame_shape[0], frame_shape[1], channel)
model.compile(optimizer=optimizer, loss=loss, metrics=[metrics])
model.load_weights(cell_model)
if contrast.lower() == "yes":
bright_frames = []
for frame in frames:
frame = ContrastNormalized(frame, percentile)
pl_.imshow(frame)
bright_frames.append(frame)
bright_frames = np_.asanyarray(bright_frames)
bright_frames = np_.expand_dims(bright_frames, axis=3)
prediction = model.predict(bright_frames)
elif contrast.lower() == "no":
frames = np_.asanyarray(frames)
frames = np_.expand_dims(frames, axis=3)
prediction = model.predict(frames)
segmentation = []
thr = 0.9
for idx, pred in enumerate(prediction):
pred = (pred.reshape(frame_shape[0], frame_shape[1]) > thr).astype(
np_.uint8)
pred = mp_.area_closing(pred)
#pred=mp_.binary_dilation(pred, mp_.disk(2))
segmentation.append(pred)
labeled_sgm = mp_.label(pred, connectivity=1)
# pl_.figure()
# pl_.imshow(pred,cmap="gray")
pl_.imsave("output/" + str(file_name) + "/segmentation/cell/frame" +
str(idx) + ".jpg",
labeled_sgm,
cmap="gray")
return segmentation
def pre_process(self):
"""
Pre-processing algorithm to reduce noise of images
:return: 2d-array of pixels
"""
# translate to gray scale the rgb image
self.to_gray_scale()
# median filtering
self.img = median(self.img)
# otsu threshold
thresh = threshold_otsu(self.img)
self.img = self.img > thresh
# closing
self.img = area_closing(self.img, area_threshold=64)
# the image pixel are considered as unsigned integer, not float
self.img = self.img.astype(np.uint8)
def esqueletoVermelho(img):
axs[1].set_title('Esqueleto da imagem de cor vermelha')
axs[1].set_axis_off() #tira o eixo x e y das imagem que fica na coluna 1
fechamento = morphology.area_closing(img, 64, 1) #retira todos os pontos
linha, coluna = fechamento.shape
for i in range(linha):
for j in range(coluna):
if (
fechamento[i][j] != 72
): #seta os pixels da fig de cor não vermelha(na escala de cinza) para branco
fechamento[i][j] = 255
thresh = threshold_otsu(
fechamento
) #auxilia na transformação da img na escola de cinza para binária// threshold automatico
binary = invert(fechamento > thresh).astype(
np.int
) #tranforma a imagem que tem a figura magenta em binaria(true/false)
esqueleto = morphology.skeletonize(binary)
axs[1].imshow(esqueleto, cmap='gray')
def esqueletoFechoConvexoVermelho(img):
axs[1].set_title('Esqueleto do fecho convexo da imagem de cor vermelha')
axs[1].set_axis_off() #tira o eixo x e y das imagem que fica na coluna 1
fechamento = morphology.area_closing(img, 64, 1) #retira todos os pontos
linha, coluna = fechamento.shape
for i in range(linha):
for j in range(coluna):
if (
fechamento[i][j] != 72
): #seta os pixels da fig de cor não vermelha(na escala de cinza) para branco
fechamento[i][j] = 255
thresh = threshold_otsu(
fechamento
) #auxilia na transformação da img na escola de cinza para binária(0-ausencia de cor 1-presença de cor)
binary = invert(
fechamento > thresh
) #tranforma a imagem em binaria em seguida faz a troca das cor dos pixels
fechoConvexo = morphology.convex_hull_object(
binary) #retorna o fecho convexo de cada objeto
esqueleto = morphology.skeletonize(fechoConvexo)
axs[1].imshow(esqueleto, cmap='gray')
def fechoConvexo(img):
axs[1].set_title('Imagem com fecho convexo dos objetos')
axs[1].set_axis_off() #tira o eixo x e y das imagem que fica na coluna 1
fechamento = morphology.area_closing(
img, 64,
1) #retira os pontos para fazer o fecho apenas das figuras restantes
linha, coluna = fechamento.shape
for i in range(linha):
for j in range(coluna):
if (
fechamento[i][j] == 88
): #seta os pixels da fig de cor magenta(na escala de cinza) para branco
fechamento[i][j] = 255
thresh = threshold_otsu(
fechamento
) #auxilia na transformação da img na escola de cinza para binária(0-ausencia de cor 1-presença de cor)
binary = invert(
fechamento > thresh
) #tranforma a imagem em binaria em seguida faz a troca das cor dos pixels
fechoConvexo = morphology.convex_hull_object(
binary) #retorna o fecho convexo de cada objeto
axs[1].imshow(fechoConvexo, cmap='gray')
def _erode_dilate(self, image, file_name, folder_name):
#get a cross kernel
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
horiz_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 1))
#area closing removes all dark structures of an image
opening = area_closing(image, 50000)
erode = binary_erosion(opening)
#erode 2 times with horizontal kernel
for i in range(2):
erode = binary_erosion(erode, horiz_kernel)
#dilate 2 times with elliptical kernel
dilate = binary_dilation(erode, kernel)
for i in range(2):
dilate = binary_dilation(dilate, kernel)
output_path = folder_name + "\\" + file_name
matplotlib.image.imsave(output_path, dilate)
return dilate
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
# Press the green button in the gutter to run the script.
from collections import deque
if __name__ == '__main__':
img = cv2.imread("im1.jpg")
"""Part1"""
image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
figure_size = 9 # the dimension of the x and y axis of the kernel.
kernel = np.ones((3, 3), np.uint8)
new_image = cv2.GaussianBlur(image, (15, 19), 0)
edges = cv2.Canny(new_image, 0, 20)
kernel = np.ones((3, 3), np.uint8)
dilate = cv2.dilate(edges, kernel, iterations=4)
foreground = area_closing(dilate, 1024, connectivity=1)
plt.imshow(foreground, cmap=plt.cm.gray)
plt.show()
gold = np.loadtxt("im3_gold_mask.txt")
gold1 = np.loadtxt("im3_gold_cells.txt")
gold_int = gold.astype(int)
gold1_int = gold1.astype(int)
foreground[foreground == 255] = 1
reshaped_gold = gold_int.reshape(-1)
reshaped1_gold = gold1_int.reshape(-1)
print(reshaped_gold)
print(reshaped1_gold)
foreground_final = foreground.reshape(-1)
"""print(classification_report(reshaped_gold, foreground_final))"""
def buttonSave(arg):
copy = arg[1]
imageTemp = arg[2]
filterTry = filterVar.get()
if (filterTry == 1):
copy = cv2.GaussianBlur(copy, (5, 5), 0)
elif (filterTry == 2):
copy = cv2.Canny(copy, 100, 150)
elif (filterTry == 3):
copy = filters.roberts(imageTemp)
elif (filterTry == 4):
copy = filters.sato(imageTemp)
elif (filterTry == 5):
copy = filters.scharr(imageTemp)
elif (filterTry == 6):
copy = filters.sobel(imageTemp)
elif (filterTry == 7):
copy = filters.unsharp_mask(copy, radius=30, amount=3)
elif (filterTry == 8):
#copy = filters.median(imageTemp, disk(5))
b, g, r = cv2.split(copy)
b = filters.median(b, disk(5))
g = filters.median(g, disk(5))
r = filters.median(r, disk(5))
copy = cv2.merge((b, g, r))
elif (filterTry == 9):
copy = filters.prewitt(imageTemp)
elif (filterTry == 10):
copy = filters.rank.modal(imageTemp, disk(5))
flag = 0
if (np.ndim(copy) == 2):
flag = 0
else:
flag = 1
if (hEsitleme.get() or hGrafik.get()):
if (flag):
copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY)
if (hGrafik.get()):
plt.hist(copy.ravel(), 256, [0, 256])
plt.show()
if (hEsitleme.get()):
copy = cv2.equalizeHist(copy)
if (uzaysalVars[0].get()):
reScaleRatio = float(uzaysalVarsInputs[0].get())
if (np.ndim(copy) == 3):
b, g, r = cv2.split(copy)
b = transform.rescale(b, reScaleRatio)
g = transform.rescale(g, reScaleRatio)
r = transform.rescale(r, reScaleRatio)
copy = cv2.merge((b, g, r))
else:
copy = transform.rescale(copy, reScaleRatio)
if (uzaysalVars[1].get()):
resizeY = float(uzaysalVarsInputs[1].get())
resizeX = float(uzaysalVarsInputs[2].get())
if (np.ndim(copy) == 3):
b, g, r = cv2.split(copy)
b = transform.resize(
b, (b.shape[0] // resizeX, b.shape[1] // resizeY),
anti_aliasing=True)
g = transform.resize(
g, (g.shape[0] // resizeX, g.shape[1] // resizeY),
anti_aliasing=True)
r = transform.resize(
r, (r.shape[0] // resizeX, r.shape[1] // resizeY),
anti_aliasing=True)
copy = cv2.merge((b, g, r))
else:
copy = transform.resize(
copy, (copy.shape[0] // resizeX, copy.shape[1] // resizeY),
anti_aliasing=True)
if (uzaysalVars[2].get()):
copy = transform.swirl(copy, rotation=0, strength=10, radius=120)
if (uzaysalVars[3].get()):
copy = transform.rotate(copy,
int(uzaysalVarsInputs[3].get()),
resize=True)
if (uzaysalVars[4].get()):
copy = copy[:, ::-1]
if (yogunlukVars[0].get() or yogunlukVars[1].get()):
if (yogunlukVars[0].get()):
startINX = int(yogunlukVars[2].get())
finishINX = int(yogunlukVars[3].get())
copy = exposure.rescale_intensity(copy,
in_range=(startINX,
finishINX))
if (yogunlukVars[1].get()):
startOUTX = int(yogunlukVars[4].get())
finishOUTX = int(yogunlukVars[5].get())
copy = exposure.rescale_intensity(copy,
out_range=(startOUTX,
finishOUTX))
morfoTry = morfVar.get()
morfoGirisN = 0
if (np.ndim(copy) == 3):
morfoGirisN = 1
if (morfoTry == 1):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.area_closing(b, 128, 9)
g = morphology.area_closing(g, 128, 9)
r = morphology.area_closing(r, 128, 9)
copy = cv2.merge((b, g, r))
else:
copy = morphology.area_closing(copy)
elif (morfoTry == 2):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.area_opening(b, 128, 9)
g = morphology.area_opening(g, 128, 9)
r = morphology.area_opening(r, 128, 9)
copy = cv2.merge((b, g, r))
else:
copy = morphology.area_opening(copy)
elif (morfoTry == 3):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.erosion(b, disk(6))
g = morphology.erosion(g, disk(6))
r = morphology.erosion(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.erosion(copy, disk(6))
elif (morfoTry == 4):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.dilation(b, disk(6))
g = morphology.dilation(g, disk(6))
r = morphology.dilation(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.dilation(copy, disk(6))
elif (morfoTry == 5):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.opening(b, disk(6))
g = morphology.opening(g, disk(6))
r = morphology.opening(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.opening(copy, disk(6))
elif (morfoTry == 6):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.closing(b, disk(6))
g = morphology.opening(g, disk(6))
r = morphology.opening(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.opening(copy, disk(6))
elif (morfoTry == 7):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.white_tophat(b, disk(6))
g = morphology.white_tophat(g, disk(6))
r = morphology.white_tophat(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.white_tophat(copy, disk(6))
elif (morfoTry == 8):
if (morfoGirisN):
b, g, r = cv2.split(copy)
b = morphology.black_tophat(b, disk(6))
g = morphology.black_tophat(g, disk(6))
r = morphology.black_tophat(r, disk(6))
copy = cv2.merge((b, g, r))
else:
copy = morphology.black_tophat(copy, disk(6))
elif (morfoTry == 10):
if (morfoGirisN):
copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY)
copy = exposure.rescale_intensity(copy)
local_maxima = extrema.local_maxima(copy)
label_maxima = measure.label(local_maxima)
copy = color.label2rgb(label_maxima,
copy,
alpha=0.7,
bg_label=0,
bg_color=None,
colors=[(1, 0, 0)])
elif (morfoTry == 9):
if (morfoGirisN):
copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY)
copy = exposure.rescale_intensity(copy)
h = 0.05
h_maxima = extrema.h_maxima(copy, h)
label_h_maxima = measure.label(h_maxima)
copy = color.label2rgb(label_h_maxima,
copy,
alpha=0.7,
bg_label=0,
bg_color=None,
colors=[(1, 0, 0)])
arg[1] = copy
arg[2] = imageTemp
cv2.imshow("org", copy)
cv2.waitKey(0)
cv2.destroyAllWindows()
"""
th_2 = filters.threshold_sauvola(img_hsv, window_size=7) img_th2 = img_hsv < th_2 plt.imshow(img_th2) # combine results of both filters img_bin = np.logical_or(img_th1, img_th2) plt.imshow(img_bin) # Use erosion to filter out noise (dots) then apply median filter to smooth and isolate regions from skimage.morphology import area_closing, disk from skimage.filters import median from scipy import ndimage as ndi img_bin = area_closing(img_bin, area_threshold=128) img_bin = median(img_bin, disk(5)) # img_bin = ndi.binary_fill_holes(img_bin) plt.imshow(img_bin) # ============================================================================ # import matplotlib.pyplot as plt import matplotlib.patches as mpatches from skimage import data from skimage.filters import threshold_otsu from skimage.segmentation import clear_border from skimage.measure import label, regionprops
def fill_holes(image: np.ndarray, filling_range=400):
print("Hole Filling...", end='', flush=True)
result = morphology.area_closing(image, area_threshold=filling_range)
print('[DONE]')
return result
import skimage.morphology as mp
import cv2 as cv
img = cv.imread("bw.jpg")
closed = mp.area_closing(img, 135, connectivity=1)
cv.imshow('closed', closed)
cv.waitKey(0)
def inpaint(label_img):
return morphology.area_closing(label_img, area_threshold=2000)
def img_to_nodes(img, mask):
def weight_boundary(graph, src, dst, n):
"""
Handle merging of nodes of a region boundary region adjacency graph.
This function computes the `"weight"` and the count `"count"`
attributes of the edge between `n` and the node formed after
merging `src` and `dst`.
Parameters
----------
graph : RAG
The graph under consideration.
src, dst : int
The vertices in `graph` to be merged.
n : int
A neighbor of `src` or `dst` or both.
Returns
-------
data : dict
A dictionary with the "weight" and "count" attributes to be
assigned for the merged node.
"""
default = {'weight': 0.0, 'count': 0}
count_src = graph[src].get(n, default)['count']
count_dst = graph[dst].get(n, default)['count']
weight_src = graph[src].get(n, default)['weight']
weight_dst = graph[dst].get(n, default)['weight']
count = count_src + count_dst
return {
'count': count,
'weight': (count_src * weight_src + count_dst * weight_dst) / count
}
def merge_boundary(graph, src, dst):
"""Call back called before merging 2 nodes.
In this case we don't need to do any computation here.
"""
pass
def separate_regions(labels, graph):
indices = {}
for x in range(labels.shape[0]):
for y in range(labels.shape[1]):
id = labels[x][y]
if id not in indices:
indices[id] = []
indices[id].append((x, y))
nodes = {}
for key, value in indices.items():
nodes[key] = Node(key, graph, np.array(value))
for n in nodes.values():
n.update_neighbours(nodes, labels.size)
return nodes
def relabel(labels):
idx, counts = np.unique(labels, return_counts=True)
idx = idx[counts.argsort()]
idx = idx[::-1]
ch = np.zeros_like(idx)
ch[idx] = np.arange(idx.size)
labels = ch[labels]
return labels
edges = edg(img)
labels = me.label(mask)
g = graph.rag_boundary(labels, edges)
labels = graph.merge_hierarchical(labels,
g,
thresh=0.2,
rag_copy=False,
in_place_merge=True,
merge_func=merge_boundary,
weight_func=weight_boundary)
labels = relabel(labels)
labels = mp.dilation(labels)
labels = mp.area_closing(labels, 10)
labels = mp.erosion(labels)
g = graph.rag_boundary(labels, edges)
nodes = separate_regions(labels, g)
return labels, nodes
cangurus.append(
imread("C:/Users/Windows/Desktop/RP/RP-2019.2/Projeto2/kangaroo/" + k,
True))
from skimage.transform import rescale, resize, downscale_local_mean
from skimage import filters, util
from skimage import feature
from skimage import morphology
for j in range(len(flamingos)):
flamingos[j] = resize(flamingos[j], (250, 200))
flamingos[j] = filters.median(flamingos[j])
flamingos[j] = filters.roberts(flamingos[j])
flamingos[j] = morphology.area_closing(flamingos[j])
flamingos[j] = feature.canny(flamingos[j], sigma=1)
flamingos[j] = util.img_as_float32(flamingos[j])
#imshow(flamingos[j])
#plt.show()
for j in range(len(cangurus)):
cangurus[j] = resize(cangurus[j], (250, 200))
cangurus[j] = filters.median(cangurus[j])
cangurus[j] = filters.roberts(cangurus[j])
cangurus[j] = morphology.area_closing(cangurus[j])
cangurus[j] = feature.canny(cangurus[j], sigma=1)
cangurus[j] = util.img_as_float32(cangurus[j])
#imshow(cangurus[j])
#plt.show()
out = roi
#roi = img
# segmentation
# Saliency
(success, saliencyMap) = saliency.computeSaliency(roi)
saliencyMap = (saliencyMap * 255).astype("uint8")
binout = cv2.threshold(saliencyMap, 0, 255,
cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
binout = morphology.binary_dilation(binout, selem11)
binout = morphology.binary_erosion(binout, selem5)
binout = morphology.area_closing(binout.astype('uint8'), 128)
'''
#out = saliencyMap
# level set
print('segmenting by level set')
#salinecyMap = cv2.equalizeHist(saliencyMap)
#im1 = (saliencyMap/np.max(saliencyMap)) ** 0.5 * np.max(saliencyMap)
#im1 = morphology.area_opening(cv2.threshold(saliencyMap, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1])
#im1 = morphology.area_closing(cv2.threshold(saliencyMap, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1], 1024)
phi0 = levelset.default_phi(roi)
phi = levelset.levelset(roi, phi0, 200, prior, dt=1, v=0.1, mu=500, lamb1=1, lamb2=1, tau=0.05)
binout = np.heaviside(phi, 1)
io.imshow(test)
io.show()
ch = Node(1,1,test,None)
ch.find_branch_ends()
print(ch.longest_end.count)
ch.print_longest()
'''
#####################################
img = conv(img).astype(int)
#save('convolved.jpg',img)
thresh = threshold_otsu(img)
binary_img = binary_closing(img > thresh)
binary_img = area_closing(binary_img * 255)
binary_img = binary_img > 200
#save('binary.jpg',binary_img*255)
#peak_img = peak_local_max(gaussian(binary_img*255,3),indices = False)
#save('peak.jpg',peak_img*255)
skele_img = skeletonize(binary_img)
#save('skele_img.jpg',skele_img*255)
label_img = label(skele_img)
props = regionprops(label_img)
msk_img = np.zeros(skele_img.shape)
