Nota: En esta publicación, solo trabajaremos con imágenes en escala de grises para que sea fácil de seguir.

¿Qué es una imagen?

Se puede considerar una imagen como una matriz de valores, donde cada valor representa la intensidad de un píxel. Hay tres tipos principales de formatos de imagen:

• Binario: una imagen en este formato está representada por una única matriz 2D con valores de 0 (negro) y 1 (blanco). Es la forma más sencilla de representación de imágenes.

• Escala de grises: En este formato, una imagen se representa mediante una única matriz 2-D con valores que van de 0 a 255; donde 0 representa negro y 255 representa blanco. Los valores intermedios representan distintos tonos de gris.

• Escala RGB: aquí, una imagen está representada por tres matrices 2-D (una para cada canal de color: rojo, verde y azul), con valores que van de 0 a 255. Cada matriz contiene valores de píxeles para un componente de color y la combinación de estos tres canales nos da la imagen a todo color.

Filtros

Los filtros son herramientas que se utilizan para modificar imágenes aplicando ciertas operaciones. Un filtro es una matriz (también llamada núcleo) que se mueve a través de la imagen y realiza cálculos sobre los valores de píxeles dentro de su ventana. Cubriremos dos tipos comunes de filtros: filtros de media y filtros de mediana.

Filtros medios

Se utiliza un filtro medio para reducir el ruido promediando los valores de píxeles dentro de una ventana. Reemplaza el píxel central de la ventana con el promedio de todos los valores de píxeles dentro de esa ventana. La función cv2.blur() aplica un filtro medio con un tamaño de núcleo de 3x3, lo que significa que considera una ventana de 3x3 de píxeles alrededor de cada píxel para calcular el promedio. Esto ayuda a suavizar la imagen.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Applies a Mean Filter of size 3 x 3
blurred_image = cv2.blur(image, (3, 3))

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(blurred_image, cmap='gray')
plt.title('Mean Filtered Image')
plt.axis("off")
plt.show()

Filtros de mediana

Se utiliza un filtro mediano para reducir el ruido reemplazando el valor de cada píxel con el valor mediano de todos los píxeles de una ventana. Es particularmente eficaz para eliminar el ruido de sal y pimienta. La función cv2.medianBlur() aplica un filtro mediano con un tamaño de núcleo de 3. Este método reemplaza cada píxel con el valor mediano de los valores de píxeles en su vecindario, lo que ayuda a preservar los bordes y al mismo tiempo eliminar el ruido. Aquí, cuanto mayor es el tamaño del núcleo, más borrosa se vuelve la imagen.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Applies a Median Filter with a kernel size of 3
blurred_image = cv2.medianBlur(image, 3)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(blurred_image, cmap='gray')
plt.title('Median Filtered Image')
plt.axis("off")
plt.show()

Filtros personalizados

Puedes crear filtros personalizados para aplicar operaciones específicas en tus imágenes. La función cv2.filter2D() le permite aplicar cualquier kernel personalizado a una imagen. La función cv2.filter2D() aplica un kernel personalizado (filtro) a la imagen. El núcleo es una matriz que define la operación que se realizará sobre los valores de los píxeles. En este ejemplo, el kernel mejora ciertas características de la imagen según los valores especificados.

import cv2
import numpy as np
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

# Define a custom filter kernel
kernel = np.array([[2, -1, 5],
                   [-5, 5, -1],
                   [0, -1, 0]])

filtered_image = cv2.filter2D(image, -1, kernel)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(filtered_image, cmap='gray')
plt.title('Filtered Image')
plt.axis('off')

plt.show()

Umbral

Nota: En los fragmentos de código, verá _ imagen al asignar la imagen con umbral. Esto se debe a que la función cv2.threshold devuelve dos valores: el valor umbral utilizado y la imagen umbralizada. Como solo necesitamos la imagen con umbral, usamos _ para ignorar el valor del umbral.

El umbral convierte una imagen en una imagen binaria estableciendo valores de píxeles según una condición. Existen varios tipos de técnicas de umbralización:

Umbral global

Umbral simple

Este método establece un valor de umbral fijo para toda la imagen. Los píxeles con valores por encima del umbral se establecen en el valor máximo (255) y los que están por debajo se establecen en 0. La función cv2.threshold() se utiliza para establecer un umbral simple. Los píxeles con una intensidad superior a 127 se configuran en blanco (255) y aquellos con una intensidad menor o igual a 127 se configuran en negro (0), lo que produce una imagen binaria.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

_, thresholded_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(thresholded_image, cmap='gray')
plt.title('Thresholded Image')
plt.axis("off")
plt.show()

Umbral de Otsu

El método de Otsu determina el valor umbral óptimo automáticamente en función del histograma de la imagen. Este método minimiza la variación intraclase y maximiza la variación entre clases. Al establecer el valor de umbral en 0 y usar cv2.THRESH_OTSU, la función calcula automáticamente el mejor valor de umbral para separar el primer plano del fondo.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

_, otsu_thresholded_image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY   cv2.THRESH_OTSU)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(otsu_thresholded_image, cmap='gray')
plt.title("Otsu's Thresholded Image")
plt.axis("off")
plt.show()

Umbral adaptativo

Umbral adaptativo medio

En el umbral adaptativo medio, el valor umbral para cada píxel se calcula en función del promedio de los valores de los píxeles en una vecindad local alrededor de ese píxel. Este método ajusta el umbral dinámicamente en diferentes regiones de la imagen. La función cv2.adaptiveThreshold() calcula el umbral para cada píxel en función del valor medio de los valores de los píxeles en una vecindad local de 11x11. Se resta un valor constante de 2 de esta media para ajustar el umbral. Este método es eficaz para imágenes con diferentes condiciones de iluminación.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

mean_adaptive_thresholded_image = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(mean_adaptive_thresholded_image, cmap='gray')
plt.title('Mean Adaptive Thresholded Image')
plt.axis("off")
plt.show()

Umbral adaptativo gaussiano

El umbral adaptativo gaussiano calcula el valor umbral para cada píxel basándose en una suma ponderada gaussiana de los valores de los píxeles en una vecindad local. Este método suele proporcionar mejores resultados en casos con iluminación no uniforme. En el umbral adaptativo gaussiano, el umbral está determinado por una suma ponderada gaussiana de valores de píxeles en una vecindad de 11x11. El valor constante 2 se resta de esta media ponderada para ajustar el umbral. Este método es útil para manejar imágenes con diferentes luces y sombras.

import cv2
import matplotlib.pyplot as plt

image = cv2.imread('McLaren-720S-Price-1200x675.jpg', cv2.IMREAD_GRAYSCALE)

gaussian_adaptive_thresholded_image = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.imshow(gaussian_adaptive_thresholded_image, cmap='gray')
plt.title('Gaussian Adaptive Thresholded Image')
plt.axis("off")
plt.show()

Referencias

• Encord.com
• Pyimagesearch.com
• Umbral de OpenCV
• Filtrado OpenCV