Visión Por Computador 3: Manejo de Imagenes¶

Información del Curso¶

Campo	Información
Asignatura	Visión Por Computador
Semana	3
Actividad	Manejo de Imagenes
Docente	Feliz Julian Gutierrez Bernal
Fecha	22 de mayo de 2026

Integrantes - Equipo de Trabajo¶

Alexander Oviedo Fadul
Maria Fernanda Ruiz Paipilla
Neheman Samir Jaller Cerchiaro
Yesith Stiven Vizcano Mican
William David Obando Lopez

Objetivo del Taller¶

Realizar la aplicación de diferentes filtros y transformaciones sobre imágenes, con el fin de comprender cómo pueden manipularse y procesarse de distintas formas, entendiendo el manejo de colores, filtros y movimientos.

Además, comprender cómo por medio de los píxeles se pueden manipular las imágenes y cómo diferentes formas de aplicar filtros permiten cambiar la perspectiva y apariencia de una imagen en un computador.

Fundamentación teórica¶

La visión por computador utiliza operaciones matemáticas para transformar imágenes y extraer información relevante a partir de sus píxeles. Una de las operaciones más importantes es la convolución, mediante la cual una matriz pequeña, llamada kernel o filtro, recorre la imagen y genera una nueva representación visual. Esta técnica permite resaltar o reducir ciertos patrones, como bordes, texturas, ruido, cambios de intensidad y formas presentes en la escena (Holzer, 2019).

Los filtros de paso bajo suavizan la imagen y reducen variaciones bruscas de intensidad, por lo que resultan útiles para disminuir ruido. En contraste, los filtros de paso alto resaltan cambios rápidos en la imagen, como detalles, contornos y texturas. Los filtros direccionales enfatizan cambios en una orientación específica, mientras que los filtros de detección de bordes permiten identificar límites entre objetos o regiones de la imagen (Hornberg, 2017).

En las redes neuronales convolucionales, este principio se automatiza: en lugar de definir manualmente todos los filtros, la red aprende diferentes kernels durante el entrenamiento. Así, las primeras capas pueden identificar bordes o texturas simples, mientras que las capas más profundas combinan esas características para reconocer formas y objetos más complejos (Dadhich, 2018). Por esta razón, la convolución es una base fundamental para comprender el funcionamiento de las CNN en tareas de clasificación, detección y análisis de imágenes.

Filtros seleccionados¶

Para cumplir con la actividad se seleccionaron ocho filtros, dos por cada tipo solicitado. Estos filtros se aplican a cuatro imágenes, generando un total de 32 resultados filtrados.

Tipo de filtro	Filtro aplicado	Propósito
Paso bajo	Promedio (Average blur)	Suavizar la imagen y reducir ruido.
Paso bajo	Gaussiano (Gaussian blur)	Suavizar preservando mejor la transición visual.
Paso alto	Enfoque (Sharpen)	Resaltar detalles y mejorar nitidez.
Paso alto	Realce de detalles	Intensificar cambios locales de intensidad.
Direccional	Sobel X	Detectar cambios verticales.
Direccional	Sobel Y	Detectar cambios horizontales.
Detección de bordes	Laplaciano	Detectar bordes en varias direcciones.
Detección de bordes	Canny	Identificar contornos mediante umbrales.

La selección de estos filtros permite comparar cómo cambia la imagen según el tipo de kernel utilizado y cómo cada transformación resalta características distintas de la escena.

1. Instalación e importación de librerías¶

En esta etapa se importan las librerías necesarias para trabajar con imágenes. OpenCV (cv2) se utiliza para el procesamiento de imágenes, google.colab.patches permite mostrar imágenes dentro de Google Colab y NumPy se usa para el manejo de matrices y datos numéricos.

Además, se crea una lista con los enlaces de las 4 imágenes que se desean trabajar, permitiendo cargarlas posteriormente para su procesamiento.

También se implementa una función de descarga utilizando gdown, con el fin de descargar automáticamente las imágenes almacenadas en Google Drive y poder manipularlas dentro del entorno de trabajo.

In [ ]:

# Importar librería OpenCV
import cv2 as cv

# Función para mostrar imágenes en Google Colab
from google.colab.patches import cv2_imshow

# Librería para manejo de matrices y datos numéricos
import numpy as np

# Librería para descargar archivos desde Google Drive
import gdown

# Librería para manejo de archivos y rutas
import os


# Lista de enlaces de imágenes en Google Drive
enlaces_drive = [
    'https://drive.google.com/file/d/1adlW8XHfo10N4f-h6atugqLdYm4cVisL/view?usp=sharing',
    'https://drive.google.com/file/d/14suZ5FWw0tQGrpoF0OqFc2pCWs6m1dzy/view?usp=sharing',
    'https://drive.google.com/file/d/1VY4Xgqin6KC1CnZsADWGRjTF1S8VPmwC/view?usp=sharing',
    'https://drive.google.com/file/d/1DKtqVf6uAUHfrLAAYkz3qzwVsrM2sAjW/view?usp=sharing'
]

# Lista para almacenar rutas locales de las imágenes
rutas_imagenes = []

print("Descargando imágenes desde Google Drive...")

# Recorrer enlaces y descargar imágenes
for i, url in enumerate(enlaces_drive):

    # Nombre local de cada imagen
    nombre_local = f"imagen_{i+1}.jpg"

    # Verificar si la imagen ya existe
    if not os.path.exists(nombre_local):

        # Descargar imagen desde Google Drive
        gdown.download(url, nombre_local, quiet=True, fuzzy=True)

    # Guardar ruta local
    rutas_imagenes.append(nombre_local)

print("¡Descargas completadas!")

Descargando imágenes desde Google Drive...
¡Descargas completadas!

2. Creación de función para generar bloques horizontales¶

En esta etapa se crea una función general encargada de generar bloques horizontales de imágenes. Primero, se toma la imagen original y se añade como base del vector horizontal.

Luego, se definen diferentes kernels utilizados para aplicar efectos como detección de bordes, enfoque y realce de imágenes.

Posteriormente, mediante un ciclo for, se aplican distintos filtros y transformaciones sobre la imagen, como enfoques, rotaciones, inversión de colores, escala de grises y efectos de realce.

Finalmente, cada imagen procesada se va uniendo horizontalmente al vector principal y la función retorna la imagen completa con todos los efectos aplicados.

In [ ]:

def procesar_bloque_horizontal(imagen):
    totalH = imagen

    f = imagen.shape[0]
    c = imagen.shape[1]
    centro = (c / 2, f / 2)

    # Kernels utilizados para aplicar diferentes efectos
    kernel_bordes = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
    kernel_enfoque = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
    kernel_realce = np.array([[-2, -1, 0], [-1, 1, 1], [0, 1, 2]])

    for j in range(8):

        # Aplicar enfoque
        if j == 0:
            imagen_procesada = cv.filter2D(imagen, -1, kernel_enfoque)

        # Rotación de 45 grados
        elif j == 1:
            M = cv.getRotationMatrix2D(centro, 45, 1.0)
            imagen_procesada = cv.warpAffine(imagen, M, (c, f))

        # Detección de bordes verticales
        elif j == 2:
            imagen_procesada = cv.filter2D(imagen, -1, kernel_bordes)

        # Invertir colores
        elif j == 3:
            imagen_procesada = cv.bitwise_not(imagen)

        # Conversión a escala de grises
        elif j == 4:
            gris = cv.cvtColor(imagen, cv.COLOR_BGR2GRAY)
            imagen_procesada = cv.cvtColor(gris, cv.COLOR_GRAY2BGR)

        # Rotación de 90 grados
        elif j == 5:
            M = cv.getRotationMatrix2D(centro, 90, 1.0)
            imagen_procesada = cv.warpAffine(imagen, M, (c, f))

        # Efecto de realce
        elif j == 6:
            imagen_procesada = cv.filter2D(imagen, -1, kernel_realce)

        # Rotación y enfoque combinados
        elif j == 7:
            M = cv.getRotationMatrix2D(centro, 15, 0.9)
            rotada = cv.warpAffine(imagen, M, (c, f))
            imagen_procesada = cv.filter2D(rotada, -1, kernel_enfoque)

        # Unir las imágenes horizontalmente
        totalH = np.hstack((totalH, imagen_procesada))

    return totalH

3. Procesamiento principal de imágenes¶

En esta etapa se realiza el bucle principal utilizando las 4 imágenes almacenadas en la lista de tipo string. Primero, cada imagen es cargada y se le cambian las dimensiones para que el resultado final se vea más organizado y no tan grande como las imágenes originales.

Posteriormente, cada imagen se envía a la función de bloques horizontales, la cual devuelve un vector con las diferentes transformaciones y filtros aplicados de forma horizontal.

Finalmente, todos los bloques generados se unen verticalmente para crear una imagen final tipo collage, mostrando todas las imágenes procesadas y sus respectivos efectos.

In [ ]:

# Variable para almacenar todas las imágenes procesadas
total = None

# Recorrer las rutas de imágenes
for ruta in rutas_imagenes:

    # Cargar imagen
    imagen = cv.imread(ruta)

    # Redimensionar imagen
    imagen = cv.resize(imagen, (250, 200), interpolation=cv.INTER_AREA)

    # Aplicar filtros y transformaciones
    totalH = procesar_bloque_horizontal(imagen)

    # Unir imágenes verticalmente
    if total is None:
        total = totalH
    else:
        total = np.vstack((total, totalH))

# Mostrar resultado final
cv2_imshow(total)

No description has been provided for this image

Análisis de resultados¶

Los filtros de paso bajo generaron imágenes más suaves, con menor nivel de detalle y transiciones visuales menos bruscas. Este comportamiento se relaciona con la reducción de ruido y con la pérdida parcial de información fina, debido a que el kernel promedia los valores de los píxeles vecinos (Holzer, 2019).

Los filtros de paso alto aumentaron la nitidez y destacaron detalles presentes en las imágenes. Estos filtros resultan útiles cuando se requiere resaltar texturas, cambios de intensidad o zonas con mayor contraste visual. Sin embargo, también pueden aumentar el ruido cuando la imagen original tiene baja iluminación o muchas variaciones locales (Hornberg, 2017).

Los filtros direccionales Sobel X y Sobel Y permitieron observar diferencias según la orientación del cambio de intensidad. Sobel X resaltó principalmente estructuras verticales, mientras que Sobel Y destacó estructuras horizontales. Esta comparación evidencia que la convolución puede orientarse a la búsqueda de patrones específicos dentro de la imagen.

Finalmente, los filtros Laplaciano y Canny facilitaron la identificación de contornos y límites entre objetos. Canny produjo bordes más definidos porque combina reducción de ruido, cálculo de gradientes y aplicación de umbrales, mientras que el Laplaciano resaltó cambios de intensidad en varias direcciones. Este comportamiento se relaciona con el principio de extracción de características utilizado posteriormente por las redes neuronales convolucionales (Dadhich, 2018).

Conclusiones¶

La aplicación de filtros de convolución permitió evidenciar que una imagen digital puede transformarse mediante operaciones sobre sus píxeles para extraer información visual relevante. Los filtros de paso bajo fueron útiles para suavizar las imágenes, mientras que los filtros de paso alto permitieron resaltar detalles y variaciones de intensidad.

Los filtros direccionales mostraron que los cambios visuales pueden analizarse según una orientación específica, y los filtros de detección de bordes permitieron identificar contornos importantes dentro de cada escena. Esto demuestra que la convolución es una operación esencial para la visión por computador, ya que permite representar características como bordes, formas y texturas.

Asimismo, el ejercicio permite comprender la relación entre los filtros manuales y las redes neuronales convolucionales. En una CNN, los filtros no se definen manualmente, sino que se aprenden durante el entrenamiento para reconocer patrones cada vez más complejos en las imágenes (Dadhich, 2018).

Referencias¶

Dadhich, A. (2018). Chapter 5. Convolutional neuronal networks. En Practical computer vision: Extract insightful information from images using TensorFlow, Keras, and OpenCV (pp. 88–102). Packt Publishing.

Holzer, R. (2019). OpenCV tutorial documentation release 2019 (Chapters 4–6, pp. 33–63).

Hornberg, A. (Ed.). (2017). Chapter 9. Machine vision algorithms. En Handbook of machine and computer vision: The guide for developers and users (pp. 517–560). John Wiley & Sons.

OpenCV. (s. f.). OpenCV documentation. https://docs.opencv.org/

Suárez, L. (2017). Clasificación y mapeo automático de coberturas del suelo en imágenes satelitales utilizando redes neuronales convolucionales: Diseño y aplicación de redes convolucionales. Orinoquia, 21(1), 64–75.