def ej2_1_y_2():
img = cv.imread("../img/sangre.jpg",
cv.IMREAD_GRAYSCALE).astype(np.float16)
# Se ensucia con ruido Gaussiano
img_gau = func.ruidoGaussiano(img.copy(), 0, 0.05)
img_limpia_g = func.filtroMediaGeometrica(img_gau.copy(), 3, 3)
# Se ensucia con ruido Impulsivo
img_sp = func.ruidoSalPimienta(img.copy(), 1, 0.5)
img_limpia_s = func.filtroMediaContraarmonica(img_sp.copy(), -1, 3, 3)
# Para graficar vuelvo a enteros sin signo
img = img.astype(np.uint8)
img_gau = img_gau.astype(np.uint8)
img_limpia_g = img_limpia_g.astype(np.uint8)
img_sp = img_sp.astype(np.uint8)
img_limpia_s = img_limpia_s.astype(np.uint8)
func.graficar(img, 255, 0, 'gray', 'Imagen de entrada')
func.graficar(img_gau, 255, 0, 'gray', 'Imagen con ruido Gaussiano')
func.graficar(img_sp, 255, 0, 'gray', 'Imagen con ruido Sal')
func.graficar(img_limpia_g, 255, 0, 'gray',
'Imagen con ruido Gaussiano limpia')
func.graficar(img_limpia_s, 255, 0, 'gray', 'Imagen con ruido Sal limpia')
def ej3_1():
img = cv.imread('../img/Tarjeta.jpeg', cv.IMREAD_GRAYSCALE)
img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0]))
ret, imgb = cv.threshold(img, 128, 255, cv.THRESH_BINARY)
imgb = imgb.max() - imgb
func.graficar(imgb, 255, 0, 'gray', 'Imagen cargada (binarizada en 128)')
kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3))
# Erosionar con un kernel cruz
erosion1 = cv.erode(imgb, kernelcruz, iterations=1)
# func.graficar(erosion1, 255, 0, 'gray', 'Imagen erosionada con cruz')
# Dilatar con un kernel cruz
dilat1 = cv.dilate(erosion1, kernelcruz, iterations=1)
# func.graficar(dilat1, 255, 0, 'gray', 'Imagen dilatada con cruz')
# Erosionar con un kernel cruz
erosion2 = cv.erode(dilat1, kernelcruz, iterations=1)
# func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cruz 2')
median = cv.medianBlur(erosion2, 5)
# func.graficar(median, 255, 0, 'gray', 'Mediana')
# Dilatar con un kernel cruz
dilat2 = cv.dilate(median, kernelcruz, iterations=1)
# func.graficar(dilat2, 255, 0, 'gray', 'Imagen dilatada 2 con cruz')
imgf = dilat2
imgf = imgf.max() - imgf
func.graficar(imgf, 255, 0, 'gray', 'Imagen final')
def ej4_3_rechazabanda():
img = cv.imread("../img/img_degradada.tif", cv.IMREAD_GRAYSCALE)
rows, cols = img.shape
# Espectro de la imagen
# Shiftear en false para poder determinar el punto del espectro a anular
img_fft = fun.spectrum(img, shiftear=False)
# Parametros de los filtros Butterworth (dentro del pasabanda)
cortes = [.04, .043]
orden = 100
# Obtengo el filtro y filtro la imagen
filtro = fun.filtroRechazaBanda(rows, cols, cortes, orden)
img_fil = fun.filterImg(img, filtro)
# Calcular el espectro para graficarlo
img_fil_s = fun.spectrum(img_fil, shiftear=False)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(img_fft, 1, 0, 'gray', 'Espectro de la imagen original')
func.graficar(filtro, 1, 0, 'gray', 'Filtro notch')
func.graficar(img_fil, 255, 0, 'gray', 'Imagen filtrada')
func.graficar(img_fil_s, 1, 0, 'gray', 'Espectro de la imagen filtrada')
def ej5():
img = cv.imread("../img/huang3_movida.tif", cv.IMREAD_GRAYSCALE)
rows, cols = img.shape
img_fft = fun.spectrum(img)
img_fft = np.fft.ifftshift(img_fft)
func.graficar(img, 255, 0, 'gray', 'imagen original')
func.graficar(img_fft, 1, 0, 'gray', 'Espectro')
def ej3_5():
img = cv.imread('../img/Globulos Rojos.jpg', cv.IMREAD_GRAYSCALE)
ret, imgBin = cv.threshold(img, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU)
imgBin = imgBin.max() - imgBin
elemEstruc = np.ones((3, 3), np.uint8)
#Le saco los bordes a la original
imgBordes = imgBin.copy()
for i in range(2, imgBordes.shape[0] - 2):
for j in range(2, imgBordes.shape[1] - 2):
imgBordes[i, j] = 0
# Reconstruccion morfologica
#Ciclo, se repite hasta que la img anterio sea igual a la actual
imgBordesAnterior = np.zeros((imgBordes.shape[0], imgBordes.shape[1]),
np.uint8)
while ((imgBordes != imgBordesAnterior).max()):
imgBordesAnterior = imgBordes.copy()
#Diltar
dilatacion = cv.dilate(imgBordesAnterior, elemEstruc, iterations=1)
#And
imgBordes = np.bitwise_and(dilatacion, imgBin)
# LLENADO DE CENTROS
imgBordesL = imgBin.copy()
imgBordesL = imgBordesL.max() - imgBordesL
for i in range(2, imgBordes.shape[0] - 2):
for j in range(2, imgBordes.shape[1] - 2):
imgBordesL[i, j] = 0
imgBordesAnterior = np.zeros((imgBordes.shape[0], imgBordes.shape[1]),
np.uint8)
while ((imgBordesL != imgBordesAnterior).max()):
imgBordesAnterior = imgBordesL.copy()
#Diltar
dilatacion = cv.dilate(imgBordesAnterior, elemEstruc, iterations=1)
#And
imgBordesL = np.bitwise_and(dilatacion, (imgBordes.max() - imgBordes))
imgFinal = imgBordesL.max() - imgBordesL
func.graficar(imgFinal, 255, 0, 'gray', 'Imagen Binaria')
#Aplico la mascara
imgFinal = imgFinal.max() - imgFinal
imgFinal = imgFinal / imgFinal.max()
Resultado = imgFinal * img
def ej3_4():
img = cv.imread('../img/lluviaEstrellas.jpg', cv.IMREAD_GRAYSCALE)
img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0]))
# Binarizar la imagen
ret, thres = cv.threshold(img, 25, 255, cv.THRESH_BINARY)
# Elemento estructurante
structElem = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
kernelcuadrado = np.ones((3, 3), np.uint8)
# Operaciones morfológicas
ero1 = cv.erode(thres, structElem, iterations=7)
# La máscara tiene que tener valores 0 o 1
mask = ero1 / 255
# Multiplicar la mascara por la imagen original para extraer la estrella
imgf = mask * img
# func.graficar
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(thres, 255, 0, 'gray', 'Imagen umbralizada')
func.graficar(ero1, 255, 0, 'gray', 'Imagen erosionada')
func.graficar(imgf, 255, 0, 'gray', 'Estrella fugaz extraida')
def ej2_4():
img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE)
# Cantidad de filas y columnas de la imagen
rows, cols = img.shape
# Variables del filtro
corte = 0.010
# Creo el filtro Gauss en frecuencia
filtro = fun.filterGaussian(rows, cols, corte)
# Filtro pasa altos
# filtro = 1- filtro
func.graficar(filtro, filtro.max(), 0, 'gray', 'Filtro')
# Filtro la imagen en freciencia
imgFiltrada = fun.filterImg(img, filtro)
# Calculo el espectro de la imagen filtrada
espectro = fun.spectrum(imgFiltrada)
# Grafico
func.graficar(img, img.max(), 0, 'gray', 'Imagen Original')
func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada')
func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_1():
img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE)
# Cantidad de filas y columnas de la imagen
rows, cols = img.shape
# Variables del filtro
corte = .05
# Creo el filtro Gauss en frecuencia
filtro = fun.filterGaussian(rows, cols, corte)
filtroPasaAlto = 1 - filtro
a = 1.1
A = a * np.ones([rows, cols])
Hap = (A - 1) + filtroPasaAlto
# Filtro la imagen en freciencia
imgFiltrada = fun.filterImg(img, Hap)
# Calculo el espectro de la imagen filtrada
espectro = fun.spectrum(imgFiltrada)
# Grafico
func.graficar(img, img.max(), 0, 'gray', 'Imagen Original')
func.graficar(filtroPasaAlto, filtroPasaAlto.max(), 0, 'gray', 'Filtro pasa alto')
func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada (filtro de alta frecuencia)')
func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_2(show_fft = True):
img = cv.imread("../img/camaleon.tif", cv.IMREAD_GRAYSCALE)
# Cantidad de filas y columnas de la imagen
rows, cols = img.shape
# Variables del filtro
corte = 0.05
# Creo el filtro Gauss en frecuencia
filtro = fun.filterGaussian(rows, cols, corte)
filtroPasaAlto = np.ones([rows, cols]) - filtro
#Creo filtro de alta potencia
a = 0.5
b = 10
filtroEAF = a + b * filtroPasaAlto
# Filtro la imagen en freciencia
imgFiltrada = fun.filterImg(img, filtroEAF)
#TDF de la imagen original
espectro = fun.spectrum(img)
# TDF de la imagen filtrada
espectroFiltrada = fun.spectrum(imgFiltrada)
func.graficar(img, 255, 0, 'gray', 'Imagen Original')
func.graficar(imgFiltrada, 255, 0, 'gray', 'Imagen Filtrada (Alta potencia frecuencial)')
if show_fft:
func.graficar(espectro, espectro.max(), 0, 'gray', 'TDF imagen original')
func.graficar(espectroFiltrada, espectroFiltrada.max(), 0, 'gray', 'TDF Imagen Filtrada')
def ej4_7():
img = cv.imread("../img/HeadCT_degradada.tif", cv.IMREAD_GRAYSCALE)
img_fft = fun.spectrum(img)
img_fft = np.fft.ifftshift(img_fft)
# Cantidad de filas y columnas de la imagen
rows, cols = img.shape
# En este caso el filtro se construye a mano, y se anulan los puntos blancos
# del espectro que no tienen nada que ver con su entorno
filtro = np.ones((rows, cols))
filtro[40, 40] = 0
filtro[20, 0] = 0
filtro[0, 10] = 0
filtro[492, 0] = 0
mascara = filtro * img_fft
# Aplico el filtro
filtrada = fun.filterImg(img, filtro)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(img_fft, 1, 0, 'gray', 'Espectro')
func.graficar(filtrada, 255, 0, 'gray', 'filtrada')
func.graficar(mascara, 1, 0, 'gray', 'mascara')
def ej2_2():
img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE)
#Cantidad de filas y columnas de la imagen
rows, cols = img.shape
#Variables del filtro
corte = 0.02
order = 5
#Creo el filtro Butterworth pasa bajos en frecuencia
filtro = fun.filterButterworth(rows, cols, corte, order)
# Lo convierto a pasa altos
# filtro = 1 - filtro
func.graficar(filtro, filtro.max(), 0, 'gray', 'Filtro')
#Filtro la imagen en freciencia
imgFiltrada = fun.filterImg(img, filtro)
#Calculo el espectro de la imagen filtrada
espectro = fun.spectrum(imgFiltrada)
#Grafico
func.graficar(img, img.max(), 0, 'gray', 'Imagen Original')
func.graficar(imgFiltrada, imgFiltrada.max(), 0, 'gray', 'Imagen filtrada Corte: 0.02. Orden: 5.')
func.graficar(espectro, espectro.max(), 0, 'gray', 'Espectro')
def ej3_8():
img = cv.imread('../img/Cuerpos.jpg', cv.IMREAD_GRAYSCALE)
ret, imgBin = cv.threshold(img, 200, 255, cv.THRESH_BINARY)
imgBin = imgBin.max() - imgBin
#Dilato para llenar los huecos
B = np.ones((3, 3), np.uint8)
dilatacion = cv.dilate(imgBin, B, iterations=4)
#Erociono para que vuelva al tamaño original
erosion = cv.erode(dilatacion, B, iterations=4)
#Ahora a sacar esqueletosss
Sk = np.zeros((erosion.shape[0], erosion.shape[1]), np.uint8)
Paso1 = cv.erode(erosion, B, iterations=1)
while (Paso1.max() != 0):
Paso2 = func.cierre(Paso1, B)
Sk = Sk + (Paso1 - Paso2)
Paso1 = cv.erode(Paso1, B, iterations=1)
func.graficar(img, 255, 0, 'gray', 'Imagen de entrada')
func.graficar(imgBin, 255, 0, 'gray', 'Imagen umbralizada')
func.graficar(erosion, 255, 0, 'gray', 'Dilatada')
func.graficar(Sk, 255, 0, 'gray', 'Skeleton')
def ej3_3():
img = cv.imread("../img/camaleon.tif", cv.IMREAD_GRAYSCALE)
# Defino el filtro en el espacio
n = 5
filtered = cv.filter2D(img, -1, np.ones((n, n), np.float32) / (n * n))
# Coeficiente del filtro de alta potencia
A = 2.0
# Filtro de alta potencia
img2 = cv.subtract(A * img, filtered.astype(np.float))
func.graficar(img2, 255, 0, 'gray', 'Imagen filtrada (Alta potencia espacial)')
# Filtro de alta potencia en frecuencia
ej3_2(show_fft = False)
def ej1_1():
# Implementación de distintos tipos de ruido: Descomentar la gráfica del que sea de interés
# Cargar imagen
img = cv.imread("../img/cameraman.tif", cv.IMREAD_GRAYSCALE)
# Ruidos (copiar imagen y generar ruido)
salYpimienta = img.copy()
salYpimienta = func.ruidoSalPimienta(salYpimienta, 0.5, 0.03)
gauss = img.copy()
gauss = func.ruidoGaussiano(gauss, 0, 0.02)
raileigh = img.copy()
raileigh = func.ruidoRayleigh(raileigh, 0.5)
uniforme = img.copy()
uniforme = func.ruidoUniforme(uniforme, 0, 0.5)
exponencial = img.copy()
exponencial = func.ruidoExponencial(exponencial, 0.09)
gamma = img.copy()
gamma = func.ruidoGamma(gamma, 1, 0.2)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen de entrada')
func.histograma(img, 'Imagen de entrada')
# func.graficar(salYpimienta, 255, 0, 'gray', 'Ruido Sal y pimienta')
# func.histograma(salYpimienta, 'Ruido sal y pimienta')
# func.graficar(gauss, 255, 0, 'gray', 'Ruido Gaussiano')
# func.histograma(gauss, 'Ruido gaussiano')
# func.graficar(raileigh, 255, 0, 'gray', 'Ruido Raileigh')
# func.histograma(raileigh, 'Ruido Raileigh')
# func.graficar(uniforme, 255, 0, 'gray', 'Ruido Uniforme')
# func.histograma(uniforme, 'Ruido Uniforme')
# func.graficar(exponencial, 255, 0, 'gray', 'Ruido Exponencial')
# func.histograma(exponencial, 'Ruido Exponencial')
func.graficar(gamma, 255, 0, 'gray', 'Ruido Gamma')
func.histograma(gamma, 'Ruido Gamma')
def ej6_B():
# Analisis de B
imgB = cv.imread("../img/FAMILIA_b.jpg", cv.IMREAD_GRAYSCALE)
func.graficar(imgB, 255, 0, 'gray', 'Original B')
# Extraigo la subimagen que quiero segmentar de cada imagen a analizar
sub_imgB = sub_image("../img/FAMILIA_b.jpg")
sub_imgB = cv.cvtColor(sub_imgB, cv.COLOR_BGR2GRAY)
# Analizo el histograma de sub imagen
func.histograma(sub_imgB, "Histograma B")
#Calculo los parametros estadisticos para cada sub imagen
mediaB = np.mean(sub_imgB)
varianzaB = np.var(sub_imgB)
print mediaB, varianzaB
#La imagen B tiene ruido uniforme y gausiano
sub_imgB_midPoint = func.filter_midPoint3(sub_imgB)
imgB_midPoint = func.filter_midPoint3(imgB)
mediaB_midPoint = np.mean(sub_imgB_midPoint)
varianzaB_midPoint = np.var(sub_imgB_midPoint)
print mediaB_midPoint, varianzaB_midPoint
func.histograma(sub_imgB_midPoint, "B Despues de filtro de punto medio")
sub_imgB_adaptative = func.filter_adaptative(sub_imgB, varianzaB)
imgB_adaptative = func.filter_adaptative(imgB, varianzaB)
mediaB_adaptative = np.mean(sub_imgB_adaptative)
varianzaB_adaptative = np.var(sub_imgB_adaptative)
print mediaB_adaptative, varianzaB_adaptative
func.histograma(sub_imgB_adaptative, "B Despues de filtro adaptativo")
# Grafico resultados
func.graficar(imgB, 255, 0, 'gray', 'Original B')
func.graficar(sub_imgB, 255, 0, 'gray', 'zona homogenea de B')
func.graficar(imgB_midPoint, 255, 0, 'gray', 'B con filtro de punto medio')
func.graficar(imgB_adaptative, 255, 0, 'gray', 'B con filtro adaptativo')
def ej3_7v2():
img = cv.imread('../img/Melanoma.jpg', cv.IMREAD_GRAYSCALE)
img_o = cv.imread('../img/Melanoma.jpg')
ret, imgBin = cv.threshold(img, 170, 255, cv.THRESH_BINARY)
# Filtro pasa bajos
n = 15
img_fpb = cv.blur(img, (n, n))
# Umbral
ret, umbral = cv.threshold(img_fpb, 164, 255, cv.THRESH_BINARY)
ret_img, contours, hierarchy = cv.findContours(umbral, 2, 1)
cnt = contours[0]
hull = cv.convexHull(cnt, returnPoints=False)
defects = cv.convexityDefects(cnt, hull)
# imgn = cv.drawContours(img_o, contours, -1, [255, 0, 0])
func.graficar(img_o[:, :, ::-1], 255, 0, 'gray', 'Contorno')
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = tuple(cnt[s][0])
end = tuple(cnt[e][0])
plt.plot(start, end, 'ro-')
# cv.line(img, start, end, [0, 255, 0], 2)
plt.figure()
# points = np.transpose(np.where(umbral))
# hull = scipy.spatial.ConvexHull(points)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen de entrada')
func.graficar(umbral, 255, 0, 'gray', 'Imagen umbralizada')
def ej2():
"""
cv2.HoughLines():
First parameter, Input image should be a binary image, so apply threshold or use canny edge
detection before finding applying hough transform. Second and third parameters are \rho and \theta
accuracies respectively. Fourth argument is the threshold, which means minimum vote it should get
for it to be considered as a line.
"""
img_o = cv.imread("../img/letras1.tif")
img_p = img_o.copy()
img = cv.cvtColor(img_o, cv.COLOR_BGR2GRAY)
func.graficar(img, 255, 0, 'gray', 'Bordes')
bordes = cv.Canny(img, 20, 30)
func.graficar(bordes, 255, 0, 'gray', 'Bordes')
lines = cv.HoughLines(bordes, 1, np.pi / 180, 90)
for linea in lines:
for rho, theta in linea:
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
cv.line(img_o, (x1, y1), (x2, y2), (0, 0, 255), 2)
func.graficar(img_o[:, :, ::-1], 255, 0, 'gray', 'Hough')
"""
cv2.HoughLinesP():
In the hough transform, you can see that even for a line with two arguments, it takes a lot of computation.
Probabilistic Hough Transform is an optimization of Hough Transform we saw. It doesn’t take all the points into
consideration, instead take only a random subset of points and that is sufficient for line detection. Just we
have to decrease the threshold. See below image which compare Hough Transform and Probabilistic Hough Transform
in hough space.
"""
minLineLength = 100
maxLineGap = 10
lines = cv.HoughLinesP(bordes, 1, np.pi / 180, 100, minLineLength,
maxLineGap)
for line in lines:
cv2.line(img_p, (line[0][0], line[0][1]), (line[0][2], line[0][3]),
(0, 0, 255), 6)
func.graficar(img_p[:, :, ::-1], 255, 0, 'gray', 'HoughP')
def ej3_7():
img = cv.imread('../img/Melanoma.jpg', cv.IMREAD_GRAYSCALE)
ret, imgBin = cv.threshold(img, 170, 255, cv.THRESH_BINARY)
imgBin = cv.medianBlur(imgBin, 31)
imgBin = imgBin.max() - imgBin
# #imgBin = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2)
#
#Elementos estructurantes
B1 = np.array(([1, 0, 0], [1, 0, 0], [1, 0, 0]), dtype="uint8")
B2 = np.array(([1, 1, 1], [0, 0, 0], [0, 0, 0]), dtype="uint8")
B3 = np.array(([0, 0, 1], [0, 0, 1], [0, 0, 1]), dtype="uint8")
B4 = np.array(([0, 0, 0], [0, 0, 0], [1, 1, 1]), dtype="uint8")
#
# # FUNCION IMPORTANTEEEEEEE!!! GUARDAR BIEN (HIT OR MISS)
# # cv.morphologyEx(input_image, cv.MORPH_HITMISS, kernel)
#
imgAnterior = np.zeros((imgBin.shape[0], imgBin.shape[1]), np.uint8)
convexHull = imgBin.copy()
while ((convexHull != imgAnterior).max()):
imgAnterior = convexHull.copy()
x1 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B1)
x2 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B2)
x3 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B3)
x4 = cv.morphologyEx(convexHull, cv.MORPH_HITMISS, B4)
convexHull = np.bitwise_or(convexHull, x1)
convexHull = np.bitwise_or(convexHull, x2)
convexHull = np.bitwise_or(convexHull, x3)
convexHull = np.bitwise_or(convexHull, x4)
func.graficar(imgBin, 255, 0, 'gray', 'Imagen original')
func.graficar(convexHull, convexHull.max(), 0, 'gray', 'Convex Hull')
def ej1_3():
cols = 512
rows = 512
linea_horizontal = np.zeros([512, 512], dtype=np.uint8)
linea_horizontal[256, 0:512] = 255
M = cv.getRotationMatrix2D((cols / 2, rows / 2), 20, 1)
linea_horizontal_r = cv.warpAffine(linea_horizontal, M, (cols, rows))
lh_rec = linea_horizontal[128:382,128:382]
lh_rec_r = linea_horizontal_r[128:382,128:382]
func.graficar(lh_rec, 255, 0, 'gray', 'Linea Horizontal Recortada')
func.graficar(lh_rec_r, 255, 0, 'gray', 'Linea Horizontal Recortada Rotada')
lh_fft = fun.spectrum(lh_rec)
lh_r_fft = fun.spectrum(lh_rec_r)
func.graficar(lh_fft, lh_fft.max(), 0, 'gray', 'Linea Horizontal Transformada')
func.graficar(lh_r_fft, lh_r_fft.max(), 0, 'gray', 'Linea Horizontal Transformada')
def ej6_C():
# Analisis de C
imgC = cv.imread("../img/FAMILIA_c.jpg", cv.IMREAD_GRAYSCALE)
sub_imgC = sub_image("../img/FAMILIA_c.jpg")
# Analizo el histograma de cada sub imagen
func.histograma(sub_imgC, "Histograma C")
# Calculo los parametros estadisticos para cada sub imagen
mediaC = np.mean(sub_imgC)
varianzaC = np.var(sub_imgC)
print mediaC, varianzaC
# La imagen C tiene ruido sal y pimienta, y ruido gausiano
sub_imgC_Mediana5x5 = cv.medianBlur(sub_imgC, 5)
imgCMediana5x5 = cv.medianBlur(imgC, 5)
mediaC_Mediana5x5 = np.mean(sub_imgC_Mediana5x5)
varianzaC_Mediana5x5 = np.var(sub_imgC_Mediana5x5)
print 'mediana 5x5'
print mediaC_Mediana5x5, varianzaC_Mediana5x5
func.histograma(sub_imgC_Mediana5x5, "C Despues de mediana 5x5")
# Mediana 9x9
sub_imgC_Mediana9x9 = cv.medianBlur(sub_imgC, 9)
imgCMediana9x9 = cv.medianBlur(imgC, 9)
mediaC_Mediana9x9 = np.mean(sub_imgC_Mediana9x9)
varianzaC_Mediana9x9 = np.var(sub_imgC_Mediana9x9)
print 'mediana 9x9'
print mediaC_Mediana9x9, varianzaC_Mediana9x9
func.histograma(sub_imgC_Mediana9x9, "C Despues de mediana 9x9")
# Grafico resultados
func.graficar(imgC, 255, 0, 'gray', 'Original C')
func.graficar(sub_imgC, 255, 0, 'gray', 'Zona homogenea de C')
func.graficar(imgCMediana5x5, 255, 0, 'gray', 'C despues de mediana 5x5')
func.graficar(imgCMediana9x9, 255, 0, 'gray', 'C despues de mediana 9x9')
def ej4_4():
img = cv.imread("../img/img_degradada.tif", cv.IMREAD_GRAYSCALE)
rows, cols = img.shape
# Espectro de la imagen
# Shiftear en false para poder determinar el punto del espectro a anular
img_fft = fun.spectrum(img, shiftear=False)
# Elegir puntos a filtrar con clic
punto1 = func.elegir_punto(img_fft)
fNotch1 = fun.filtroNotch(rows, cols, punto1, pixel=True)
img_fil = fun.filterImg(img, fNotch1)
# Calcular el espectro para graficarlo
img_fil_s = fun.spectrum(img_fil, shiftear=False)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(img_fft, 1, 0, 'gray', 'Espectro de la imagen original')
func.graficar(img_fil, 255, 0, 'gray', 'Imagen filtrada')
func.graficar(img_fil_s, 1, 0, 'gray', 'Espectro de la imagen filtrada')
def ej3_3():
img = cv.imread('../img/estrellas.jpg', cv.IMREAD_GRAYSCALE)
# imgBin = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2)
ret, imgBin = cv.threshold(img, 100, 255, cv.THRESH_BINARY)
# ret, imgBin = cv.threshold(img,0,255,cv.THRESH_BINARY+cv.THRESH_OTSU)
#Creo kernel cuadrado
kernelCuad = np.ones((3, 3), np.uint8)
#Erosiono
erosionada = cv.erode(imgBin, kernelCuad, iterations=1)
func.graficar(erosionada, 255, 0, 'gray', 'Erosion')
# Enmascaro
mascara = erosionada / erosionada.max()
final = mascara * img
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(final, 255, 0, 'gray', 'Imagen Final')
def ej3_2():
img = cv.imread('../img/Caracteres.jpeg', cv.IMREAD_GRAYSCALE)
img = cv.resize(img, (2 * img.shape[1], 2 * img.shape[0]))
ret, imgb = cv.threshold(img, 128, 255, cv.THRESH_BINARY)
imgb = imgb.max() - imgb
func.graficar(img, 255, 0, 'gray', 'Imagen cargada (binarizada en 128)')
kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3))
# Erosionar con un kernel cruz
erosion1 = cv.erode(imgb, kernelcruz, iterations=1)
# func.graficar(erosion1, 255, 0, 'gray', 'Imagen erosionada con cruz')
# Dilatar con un kernel cruz
dilat1 = cv.dilate(erosion1, kernelcruz, iterations=1)
# func.graficar(dilat1, 255, 0, 'gray', 'Imagen dilatada con cruz')
# Erosionar con un kernel cruz
erosion2 = cv.erode(dilat1, kernelcruz, iterations=1)
# func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cruz 2')
median = cv.medianBlur(erosion2, 5)
# func.graficar(median, 255, 0, 'gray', 'Mediana')
# Erosionar con un kernel cuadrado
kernelcuadrado = np.ones((3, 3), np.uint8)
erosion2 = cv.dilate(median, kernelcuadrado, iterations=1)
# func.graficar(erosion2, 255, 0, 'gray', 'Imagen erosionada con cuadrado')
imgf = erosion2
imgf = imgf.max() - imgf
func.graficar(imgf, 255, 0, 'gray', 'Imagen final')
# Hasta acá se extraen las letras grandes..
# Ahora se extraen los simbolos
simbolos = img * imgf
erosion3 = cv.erode(simbolos, kernelcruz, iterations=1)
func.graficar(erosion3, 255, 0, 'gray', 'Simbolos')
def ej4():
#Filtrado Homomorfico
img_o = cv.imread("../img/reunion.tif", cv.IMREAD_GRAYSCALE)
img = np.array(img_o, dtype=np.float32)
rows, cols = img.shape
# Logaritmo de la imagen original
img_log = np.log(1+img)
# Variables del filtro
corte = 0.01
order = 5
gL = 0.5
gH = 0.6
# Filtro que voy a usar en frecuencia (basado en el gaussiano)
filtro = func.filterHomomorfico(rows, cols, corte, gL, gH, order)
# Filtro la imagen
imgFiltrada = fun.filterImg(img_log, filtro)
# Saco el logaritmo
imgFinal = np.exp(imgFiltrada - imgFiltrada.min())
imgFinal = 255 * imgFinal/imgFinal.max()
# La imagen se abrió como flotante para poder manipular sus números con mayor precisión
# Luego de operar, se debe volver a 8 bits entero sin signo .
img = np.array(img, dtype=np.uint8)
imgFinal = np.array(imgFinal, dtype=np.uint8)
# Ecualizacion (Ver si mejora)
imgeq = cv.equalizeHist(imgFinal)
# Graficar
func.graficar(img, 255, 0, 'gray', 'Imagen original')
func.graficar(imgFinal, 255, 0, 'gray', 'Imagen Final')
func.graficar(imgeq, 255, 0, 'gray', 'Imagen Final ecualizada')
#func.graficar(maskFoco,'mascara circular de lente camara')
# =============================================================================
# #############################################################################
# #############################################################################
# ------------------------------ SEGMENTACIÓN ---------------------------------
# #############################################################################
# #############################################################################
# =============================================================================
#
# Se convierte la imagen a escala de grises
img_g=cv.cvtColor(img, cv.COLOR_BGR2GRAY)
func.graficar(img_g,'imagen original en gris')
# Filtro de medias no locales
img_g= cv.fastNlMeansDenoising(img_g,None)
# Observación de histograma por si hay datos interesantes
func.histograma(img_g,grafico='true',titulo='histograma gray del lunar')
# Se obtiene máscara óptima
ret, img_mod_tresh = cv.threshold(img_g, 0, 255, cv.THRESH_BINARY_INV+cv.THRESH_OTSU)
print("umbral optimo de otsu",ret)
# Se mejora la máscara con morfologia
kernelelipse = cv.getStructuringElement(cv.MORPH_ELLIPSE, (5, 5))
img_mod = funcEmi.apertura(img_mod_tresh,kernelelipse)
kernelelipse = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3))
def ej1_4():
img1 = cv.imread("../img/imagenB.tif", cv.IMREAD_GRAYSCALE)
img2 = cv.imread("../img/cameraman.tif", cv.IMREAD_GRAYSCALE)
img3 = cv.imread("../img/hubble.tif", cv.IMREAD_GRAYSCALE)
img4 = cv.imread("../img/chairs.jpg", cv.IMREAD_GRAYSCALE)
sp1 = fun.spectrum(img1)
sp2 = fun.spectrum(img2)
sp3 = fun.spectrum(img3)
sp4 = fun.spectrum(img4)
func.graficar(img1, img1.max(), 0, 'gray', 'Original: imagenB.tif')
func.graficar(sp1, sp1.max(), 0, 'gray', 'FFT: imagenB.tif')
func.graficar(img2, img2.max(), 0, 'gray', 'Original: cameraman.tif')
func.graficar(sp2, sp2.max(), 0, 'gray', 'FFT: cameraman.tif')
func.graficar(img3, img3.max(), 0, 'gray', 'Original: hubble.tif')
func.graficar(sp3, sp3.max(), 0, 'gray', 'FFT: hubble.tif')
func.graficar(img4, img4.max(), 0, 'gray', 'Original: chairs.jpg')
func.graficar(sp4, sp4.max(), 0, 'gray', 'FFT: chairs.jpg')
def ej3_6():
img = cv.imread('../img/Rio.jpeg')
rows, cols = img.shape[0:2]
# ret, imgBin = cv.threshold(img, 114, 255, cv.THRESH_BINARY)
img_hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
H = img_hsv[:, :, 0]
S = img_hsv[:, :, 1]
V = img_hsv[:, :, 2]
# La idea es ir segmentando por partes (y luego sumar esas partes), empezando por
# lo más fácil, que es el río. Su H está alrededor de 112.
h_rio, tol1 = 112, 25
ret, mask_rio1 = cv.threshold(H, h_rio - tol1, 255, cv.THRESH_BINARY)
mask_rio1 = cv.medianBlur(mask_rio1, 9)
mask_rio1 = cv.blur(mask_rio1, (15, 15))
ret, mask_rio1 = cv.threshold(mask_rio1, 85, 255, cv.THRESH_BINARY)
# Ahora saco los afluentes, para ello primero umbralizo en S. Luego veo que zonas grandes
# quedaron y comparo con la informacion de la mascara 1, ya que las zonas grandes deben tener
# un color similar.
s_aflu = 128
ret, mask_rio2 = cv.threshold(S, s_aflu, 255, cv.THRESH_BINARY)
mask_rio2 = 255 - mask_rio2
# Obtengo de esta mascara las zonas grandes (mediana) y mediante la resta con la mascara 1
mask_rio3 = cv.medianBlur(mask_rio2, 47)
mask_rio4 = mask_rio3 - mask_rio1
# La diferencia entre la máscara 3 y la 4, es que la 3 contiene partes del río que sí
# corresponden, mientras que la 4 tiene zonas homogeneas grandes que no corresponden.
ret, mask_rio4 = cv.threshold(mask_rio4, 200, 255, cv.THRESH_BINARY)
mask_rio4 = (255 - mask_rio4) / 255
# Elimino de la máscara 2 lo que no va:
mask_rio2 = mask_rio2 * mask_rio4
# Componentes conectadas de la mascara 2
output = cv.connectedComponentsWithStats(mask_rio2, 4, cv.CV_32S)
labels = output[1]
# Tengo muchas componentes conectadas, como 5000, por lo tanto, ubico cual es la que me
# interesa y al resto la anulo o las dejo como estan
labels[np.where(labels > 208)] = 0
# Para poder umbralizar tengo que cambiar el tipo de entero
labels = labels.astype(np.uint8)
# umbralizo en el label que me interesa
ret, mask_rio2 = cv.threshold(labels, 190, 255, cv.THRESH_BINARY)
# sumo las mascaras
mask_rio = mask_rio1 + mask_rio2
# Para multiplicarla, convierto los valores distintos de cero a 1
mask_rio[np.where(mask_rio != 0)] = 1
# Dilato para conectar un poco
mask_rio = cv.dilate(mask_rio, np.ones(5, dtype=np.uint8), iterations=3)
# Aplico la mascara a la imagen original
solorio = img.copy()
solorio[:, :, 0] = img[:, :, 0] * mask_rio
solorio[:, :, 1] = img[:, :, 1] * mask_rio
solorio[:, :, 2] = img[:, :, 2] * mask_rio
# todo mejorar: Aplicar desenfoque a la máscara, eliminar partes de la mascara que sean G en la img
func.graficar(img[:, :, ::-1], 255, 0, 'gray', 'Imagen de entrada')
# func.graficar(H, 255, 0, 'gray', 'Canal H')
# func.graficar(S, 255, 0, 'gray', 'Canal S')
# func.graficar(V, 255, 0, 'gray', 'Canal V')
# func.graficar(mask_rio1, 255, 0, 'gray', 'Mascara 1')
# func.graficar(mask_rio2, 255, 0, 'gray', 'Mascara 2')
# func.graficar(mask_rio3, 255, 0, 'gray', 'Mascara 3')
# func.graficar(mask_rio4, 1, 0, 'gray', 'Mascara 4')
# func.graficar(mask_rio, 255, 0, 'gray', 'Suma')
func.graficar(solorio[:, :, ::-1], 255, 0, 'gray', 'Solo rio')
def ej1_1y1_2():
linea_vertical = np.zeros([512,512],dtype=np.uint8)
linea_vertical[0:512,256] = 255
linea_horizontal = np.zeros([512,512],dtype=np.uint8)
linea_horizontal[256, 0:512] = 255
circulo = np.zeros([512,512],dtype=np.uint8)
cv.circle(circulo, (256,256), 50, 255, -1)
cv.circle(circulo, (256,256), 49, 0, -1)
rectangulo = np.zeros([512,512],dtype=np.uint8)
cv.rectangle(rectangulo, (156,206), (356, 306), 255,3)
rectanguloC = np.zeros([512, 512], dtype=np.uint8)
cv.rectangle(rectanguloC, (100, 206), (300, 306), 255, 3)
cuadrado = np.zeros([512,512],dtype=np.uint8)
cv.rectangle(cuadrado, (206,206), (306, 306), 255,3)
lv_fft = fun.spectrum(linea_vertical)
lh_fft = fun.spectrum(linea_horizontal)
cr_fft = fun.spectrum(circulo)
rc_fft = fun.spectrum(rectangulo)
rc_fft2 = fun.spectrum(rectanguloC)
cd_fft = fun.spectrum(cuadrado)
func.graficar(linea_vertical, 255, 0, 'gray', 'Linea Vertical')
func.graficar(lv_fft, lv_fft.max(), 0, 'gray', 'Linea Vertical Transformada')
func.graficar(linea_horizontal, 255, 0, 'gray', 'Linea Horizontal')
func.graficar(lh_fft, lh_fft.max(), 0, 'gray', 'Linea Horizontal Transformada')
func.graficar(circulo, 255, 0, 'gray', 'Circulo')
func.graficar(cr_fft, cr_fft.max(), 0, 'gray', 'Circulo Transformada')
func.graficar(rectangulo, 255, 0, 'gray', 'Rectangulo')
func.graficar(rc_fft, rc_fft.max(), 0, 'gray', 'Rectangulo Transformada')
func.graficar(rectanguloC, 255, 0, 'gray', 'Rectangulo corrido')
func.graficar(rc_fft2, rc_fft2.max(), 0, 'gray', 'Rectangulo Transformada Corrida')
func.graficar(cuadrado, 255, 0, 'gray', 'Cuadrado')
func.graficar(cd_fft, cd_fft.max(), 0, 'gray', 'Cuadrado Transformada')
def ej2_1():
img = cv.imread("../img/huang1.jpg", cv.IMREAD_GRAYSCALE)
rows, cols = img.shape
# Filtros pasa altos: Para que funcionen, comentar los pasa bajos.
# imgf1 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.08))
# spec1 = fun.spectrum(fun.filterImg(img,fun.filterIdeal(rows,cols,0.15)))
#
# imgf2 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.15))
# spec2 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.15)))
#
# imgf3 = fun.filterImg(img, 1-fun.filterIdeal(rows,cols,0.6))
# spec3 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.6)))
# Filtros pasa bajos
imgf1 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.08))
spec1 = fun.spectrum(fun.filterImg(img,fun.filterIdeal(rows,cols,0.15)))
imgf2 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.15))
spec2 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.15)))
imgf3 = fun.filterImg(img, fun.filterIdeal(rows,cols,0.6))
spec3 = fun.spectrum(fun.filterImg(img, fun.filterIdeal(rows,cols,0.6)))
func.graficar(imgf1, imgf1.max(), 0, 'gray', 'Imagen para 0.1')
func.graficar(spec1, (spec1).max(), 0, 'gray', 'Espectro para 0.08')
func.graficar(imgf2, imgf2.max(), 0, 'gray', 'Imagen para 0.15')
func.graficar(spec2, (spec2).max(), 0, 'gray', 'Espectro para 0.15')
func.graficar(imgf3, imgf3.max(), 0, 'gray', 'Imagen para 0.6')
func.graficar(spec3, (spec3).max(), 0, 'gray', 'Espectro para 6')
def ej2():
img = cv.imread('../img/ej2.png', cv.IMREAD_GRAYSCALE)
func.graficar(img, 255, 0, 'gray', 'Imagen cargada')
ret, img = cv.threshold(img, 128, 255, cv.THRESH_BINARY)
# Kernel que voy a usar para ambas operaciones
kernelcuadrado = np.ones((3, 3), np.uint8)
# func.apertura con un kernel cuadrado
salida = func.apertura(img, kernelcuadrado)
func.graficar(salida, 255, 0, 'gray', 'Operacion func.apertura')
# func.cierre con un kernel cuadrado
salida = func.cierre(img, kernelcuadrado)
func.graficar(salida, 255, 0, 'gray', 'Operacion func.cierre')
# Probando otros elementos estructurantes
kernelcruz = cv.getStructuringElement(cv.MORPH_CROSS, (3, 3))
kernelelipse = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
salidacruzap = func.apertura(img, kernelcruz)
salidaelipseap = func.apertura(img, kernelelipse)
func.graficar(salidacruzap, 255, 0, 'gray',
'Operacion func.apertura con cruz')
func.graficar(salidaelipseap, 255, 0, 'gray',
'Operacion func.apertura con elipse')
salidacruzci = func.cierre(img, kernelcruz)
salidaelipseci = func.cierre(img, kernelelipse)
func.graficar(salidacruzci, 255, 0, 'gray',
'Operacion func.cierre con cruz')
func.graficar(salidaelipseci, 255, 0, 'gray',
'Operacion func.cierre con elipse')
