Example #1
0
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')
Example #2
0
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')
Example #3
0
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')
Example #4
0
# #############################################################################
# ------------------------------ 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')
Example #6
0
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')
Example #7
0
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')