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 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')
# #############################################################################
# ------------------------------ 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))
img_mod = funcEmi.apertura(img_mod,kernelelipse)
# Filtro y recuperacion de borde perdido
kernelelipse = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
img_mod = funcEmi.cierre(img_mod,kernelelipse)
img_mod = cv.dilate(img_mod,kernelelipse,1)
def parcial2018():
img = cv.imread('archivo.jpg')
img_salida = img.copy()
img_g = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
img_hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
rows, cols, c = img.shape
func.graficar(img[:, :, ::-1], 255, 0, 'gray', 'Entrada')
func.graficar(img[:, :, ::0], 255, 0, 'gray', 'R')
func.graficar(img[:, :, ::1], 255, 0, 'gray', 'G')
func.graficar(img[:, :, ::2], 255, 0, 'gray', 'B')
func.histograma(img[:, :, ::0], 'Histograma de R')
func.histograma(img[:, :, ::1], 'Histograma de G')
func.histograma(img[:, :, ::2], 'Histograma de B')
func.graficar(img_hsv[:, :, ::0], 255, 0, 'gray', 'H')
func.graficar(img_hsv[:, :, ::1], 255, 0, 'gray', 'S')
func.graficar(img_hsv[:, :, ::2], 255, 0, 'gray', 'V')
func.histograma(img_hsv[:, :, ::0], 'Histograma de H')
func.histograma(img_hsv[:, :, ::1], 'Histograma de S')
func.histograma(img_hsv[:, :, ::2], 'Histograma de V')
# ret, th_spec = cv.threshold(img_g, 235, 255, cv.THRESH_BINARY)
# lines, points = func.hough(th_spec, n = 1, plotimg = img_salida, color = (0, 0, 255))
# mask = func.segmentarColorHS(img_hsv, img_hsv, 5) # Le paso solo la cancha (no la tribuna)
# cuad = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
# erod1 = cv.erode(mask, cuad, iterations = 9)
# dilat1 = cv.dilate(erod1, cuad, iterations = 9)
# median1 = cv.medianBlur(dilat1, 5)
# blur1 = cv.GaussianBlur(median1, (9, 9), 0)
func.graficar(img_salida[:, :, ::-1], 255, 0, 'gray', 'Salida')
def ej5():
"""
Implemente un código para segmentar en forma automática la pista de aterrizaje principal en las imágenes de
aeropuertos (corrientes ruidogris.jpg e iguazu ruidogris.jpg), las cuales poseen una combinación de ruido
gaussiano e impulsivo. La salida del proceso debe ser la imagen restaurada con la pista principal coloreada
(por ejemplo, con rectas rojas).
Realice un proceso general, no adaptado a las particularidades de las imágenes de prueba (por ejemplo, la
localización, el largo o la inclinación de la pista). Para probar esta caracteristica, se le sugiere que
genere imágenes rotadas y/o desplazadas de las propuestas.
"""
# Cargamos las imágenes en escala de grises
img1 = cv.imread("../img/corrientes_ruidogris2.jpg", cv.IMREAD_GRAYSCALE)
img2 = cv.imread("../img/iguazu_ruidogris2.jpg", cv.IMREAD_GRAYSCALE)
# Subimágenes
subimgC = sub_image("../img/corrientes_ruidogris2.jpg")
subimgI = sub_image("../img/iguazu_ruidogris2.jpg")
# Eliminación del ruido impulsivo: Mediana de 3x3
# Se realiza en la imagen y en la subimagen, para analizar el histograma
medianaC = cv.medianBlur(img1, 3)
medianasC = cv.medianBlur(subimgC, 3)
medianaI = cv.medianBlur(img2, 3)
medianasI = cv.medianBlur(subimgI, 3)
# Filtro adaptativo: Para calcularlo debo pasarle una varianza estimada, se usa
# la varianza de la zona homogenea. El filtro se aplica a la imagen y a la zona
# homogenea para ver los cambios.
varianzaC = np.std(medianasC)
varianzaI = np.std(medianasI)
print "Varianzas mediana Corrientes, Iguazu: ", varianzaC, varianzaI
fasC = func.filter_adaptative2(medianasC[:, :, 0], varianzaC, 5)
faC = func.filter_adaptative2(medianaC, varianzaC, 5)
fasI = func.filter_adaptative2(medianasI[:, :, 0], varianzaI, 5)
faI = func.filter_adaptative2(medianaI, varianzaI, 5)
varianzamC = np.std(fasC)
varianzamI = np.std(fasI)
print "Varianzas mediana Corrientes, Iguazu luego de Filtro adaptativo: ", varianzamC, varianzamI
# Para dibujar líneas a color debo tener imágenes a color.
img_o1 = cv.cvtColor(faC, cv.COLOR_GRAY2RGB)
img_o2 = cv.cvtColor(faI, cv.COLOR_GRAY2RGB)
# Detectado de bordes
umbral1, umbral2 = 130, 255
canny1 = cv.Canny(faC, umbral1, umbral2)
umbral1, umbral2 = 100, 255
canny2 = cv.Canny(faI, umbral1, umbral2)
img_o3 = cv.cvtColor(canny1, cv.COLOR_GRAY2RGB)
img_o4 = cv.cvtColor(canny2, cv.COLOR_GRAY2RGB)
# Transformada de Hough
linesC = cv.HoughLines(canny1, 1, np.pi / 180, 90)
# Gráfica de la primera línea detectada (la más fuerte)
for rho, theta in linesC[0]:
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_o1, (x1, y1), (x2, y2), (0, 0, 255), 2)
cv.line(img_o3, (x1, y1), (x2, y2), (0, 0, 255), 2)
linesI = cv.HoughLines(canny2, 1, np.pi / 180, 30)
for rho, theta in linesI[0]:
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_o2, (x1, y1), (x2, y2), (0, 0, 255), 2)
cv.line(img_o4, (x1, y1), (x2, y2), (0, 0, 255), 2)
# Gráficas
func.graficar(img1, 255, 0, 'gray', 'Imagen de entrada 1')
func.graficar(img2, 255, 0, 'gray', 'Imagen de entrada 2')
func.histograma(subimgC, "Histograma de una zona homogenea de Corrientes")
func.histograma(subimgI, "Histograma de una zona homogenea de Iguazu")
func.histograma(
medianasC,
"Histograma de una zona homogenea de Corrientes luego de mediana")
func.histograma(
medianasI,
"Histograma de una zona homogenea de Iguazu luego de mediana")
func.graficar(medianaC, 255, 0, 'gray', 'Mediana de Corrientes')
func.graficar(medianaI, 255, 0, 'gray', 'Mediana de Iguazu')
func.histograma(
fasC,
"Histograma de una zona homogenea de Corrientes luego de mediana y Filtro Adaptativo"
)
func.histograma(
fasI,
"Histograma de una zona homogenea de Iguazu luego de mediana y Filtro Adaptativo"
)
func.graficar(faC, 255, 0, 'gray',
'Imagen de Corrientes despues del adaptativo')
func.graficar(faI, 255, 0, 'gray',
'Imagen de Iguazu despues del adaptativo')
func.graficar(canny1, 255, 0, 'gray', 'Canny de Corrientes')
func.graficar(canny2, 255, 0, 'gray', 'Canny de Iguazu')
func.graficar(img_o1[:, :, ::-1], 255, 0, 'gray', 'Hough de Corrientes')
func.graficar(img_o2[:, :, ::-1], 255, 0, 'gray', 'Hough de Iguazu')
func.graficar(img_o3[:, :, ::-1], 255, 0, 'gray',
'Hough de Canny de Corrientes')
func.graficar(img_o4[:, :, ::-1], 255, 0, 'gray',
'Hough de Canny de Iguazu')
def ej6_A():
imgA = cv.imread("../img/FAMILIA_a.jpg", cv.IMREAD_GRAYSCALE)
sub_imgA = sub_image("../img/FAMILIA_a.jpg")
# Analizo el histograma de cada sub imagen
func.histograma(sub_imgA, "Histograma A")
#Calculo los parametros estadisticos para cada sub imagen
mediaA = np.mean(sub_imgA)
varianzaA = np.var(sub_imgA)
print 'Media y varianza original'
print mediaA, varianzaA
#La imagen A tiene solo ruido gausiano
# Probando con un filtro de 5x5
sub_imgA5x5 = cv.GaussianBlur(sub_imgA, (5, 5), 0)
imgAGauss5x5 = cv.GaussianBlur(imgA, (5, 5), 0)
mediaGauss5x5 = np.mean(sub_imgA5x5)
varianzaGauss5x5 = np.var(sub_imgA5x5)
print 'Media y varianza Gauss5x5'
print mediaGauss5x5, varianzaGauss5x5
func.histograma(sub_imgA5x5, "A Despues de filtro gausiano 5x5")
# Probando con un filtro de 9x9
sub_imgA9x9 = cv.GaussianBlur(sub_imgA, (9, 9), 0)
imgAGauss9x9 = cv.GaussianBlur(imgA, (9, 9), 0)
mediaGauss9x9 = np.mean(sub_imgA9x9)
varianzaGauss9x9 = np.var(sub_imgA9x9)
print 'Media y varianza Gauss9x9'
print mediaGauss9x9, varianzaGauss9x9
func.histograma(sub_imgA9x9, "A Despues de filtro gausiano 9x9")
# Aplico filtro mediana a los a los 2 resultados de filtrado gausiano
# Al de 5x5
sub_imgA5x5median = cv.medianBlur(sub_imgA5x5, 5)
imgA5x5median = cv.medianBlur(imgAGauss5x5, 5)
mediaGauss5x5median = np.mean(sub_imgA5x5median)
varianzaGauss5x5median = np.var(sub_imgA5x5median)
print 'Media y varianza Gauss5x5 y mediana'
print mediaGauss5x5median, varianzaGauss5x5median
func.histograma(sub_imgA5x5median, "A Despues de gauss 5x5 y mediana")
# Al de 9x9
sub_imgA9x9median = cv.medianBlur(sub_imgA9x9, 5)
imgA9x9median = cv.medianBlur(imgAGauss9x9, 5)
mediaGauss9x9median = np.mean(sub_imgA9x9median)
varianzaGauss9x9median = np.var(sub_imgA9x9median)
print 'Media y varianza Gauss9x9 y mediana'
print mediaGauss9x9median, varianzaGauss9x9median
func.histograma(sub_imgA9x9median, "A Despues de gauss 9x9 y mediana")
# Aplico filtro punto medio despues de Gausiano
sub_imgA = cv.cvtColor(sub_imgA, cv.COLOR_BGR2GRAY)
sub_imgAPM = func.filter_midPoint3(sub_imgA)
imgAPM = func.filter_midPoint3(imgA)
mediaPM = np.mean(sub_imgAPM)
varianzaPM = np.var(sub_imgAPM)
print 'Media y varianza PM'
print mediaPM, varianzaPM
func.histograma(sub_imgAPM, "A Despues punto medio")
#sub_imgA9x9 = cv.cvtColor(sub_imgA9x9, cv.COLOR_BGR2GRAY)
#sub_imgA9x9PM = func.filter_midPoint3(sub_imgA9x9)
#imgA9x9PM = func.filter_midPoint3(imgAGauss9x9)
#mediaGauss9x9PM = np.mean(sub_imgA9x9PM)
#varianzaGauss9x9PM = np.var(sub_imgA9x9PM)
#print 'Media y varianza Gauss9x9 y PM'
#print mediaGauss9x9PM, varianzaGauss9x9PM
#plt.figure()
#plt.hist(sub_imgA9x9PM.flatten(), 255)
#plt.title('A Despues de gauss 9x9 y punto medio')
#plt.show()
#Grafico
func.graficar(imgA, 255, 0, 'gray', 'Original A')
func.graficar(sub_imgA, 255, 0, 'gray', 'Zona homogenea de analisis')
func.graficar(imgAGauss5x5, 255, 0, 'gray', 'A con filtro gaussiano 5x5')
func.graficar(imgAGauss9x9, 255, 0, 'gray', 'A con filtro gaussiano 9x9')
func.graficar(imgA5x5median, 255, 0, 'gray',
'A con filtro gaussiano 5x5 y mediana')
func.graficar(imgAPM, 255, 0, 'gray', 'A con filtro Punt Medio')
func.graficar(imgA9x9median, 255, 0, 'gray',
'A con filtro gaussiano 9x9 y mediana')
