La esencia del filtrado de imágenes digitales.

 

1. Descripción

        En la era digital, las imágenes son una parte integral de nuestra comunicación y expresión. Desde las redes sociales hasta las imágenes médicas, la calidad y el contenido de las imágenes son importantes. Aquí es donde intervienen los campos de filtrado de imágenes y convolución, brindándonos un conjunto de herramientas para transformar y refinar estas narrativas visuales.

        El filtrado de imágenes no se trata sólo de hacer que una foto se vea mejor; se trata de hacer que la imagen cuente su historia. Ya sea para reducir el ruido en exploraciones médicas, afinar los detalles intrincados de los artefactos arqueológicos o detectar bordes en vehículos autónomos, los filtros de imagen desempeñan un papel clave. Dan forma a la narrativa enfatizando ciertas características mientras dominan otras.

        La columna vertebral de este proceso es la operación de convolución, una maravilla matemática que nos permite superponer imágenes con filtros predefinidos para lograr diferentes efectos.

2. El concepto de convolución.

        La convolución es una operación matemática básica que juega un papel importante en el procesamiento de imágenes. Es una tecnología fundamental para aplicar filtros a imágenes, permitiendo tareas como desenfoque, nitidez y detección de bordes.

        El núcleo de la convolución es combinar dos funciones para producir una tercera función. En el procesamiento de imágenes, una de las funciones es la imagen de entrada y la otra es una matriz más pequeña llamada núcleo o filtro. El kernel contiene valores numéricos que definen el comportamiento del filtro. El proceso implica deslizar un núcleo sobre la imagen, multiplicar su valor por el valor de píxel correspondiente en la imagen y luego sumar los resultados. Luego, esta suma se coloca en una ubicación específica de la imagen de salida.

2.1 Convolución unidimensional

        En el contexto de las convoluciones 1D, nuestra entrada consta de matrices 1D, a menudo llamadas vectores de características.

        En el escenario de convolución más básico, realizamos una multiplicación entre esta matriz y valores numéricos (llamados filtros o pesos) para producir una matriz de salida llamada mapa de características.

        En este caso, nuestra matriz inicial tiene una dimensión de 12x1 y el filtro tiene una dimensión de 1x1, por lo tanto, la salida generada sigue teniendo un tamaño de 12x1.

        Además, a continuación se muestra un filtro de tamaño 2x1.

        Aquí multiplicamos el primer elemento de la entrada por el primer elemento del filtro, el segundo elemento de la entrada por el segundo elemento del filtro y luego los sumamos y escribimos el resultado en la matriz de salida en el primer elemento.

Aquí, como podemos observar, no podemos mover más el filtro, por lo que la salida será más pequeña, con un tamaño de 11x1.

2.2 Llenado

El relleno es la práctica de agregar píxeles adicionales alrededor de los bordes de una imagen. El propósito del relleno es afectar el tamaño de la imagen de salida después de aplicar una operación de convolución usando un núcleo o filtro específico.

A continuación, agregamos ceros a ambos extremos de la matriz de entrada, por lo que terminamos con una salida del mismo tamaño.

Hasta ahora hemos movido los filtros uno por uno hacia la derecha, pero no necesariamente tenemos que seguir haciendo esto; por ejemplo, podríamos moverlo tres.

2.3 Convolución unidimensional

Fuente

Ahora tenemos una imagen en escala de grises de 8 bits con una cuadrícula de 5x5. Los valores oscilan entre 0 y 255.

Y tenemos un kernel aleatorio de 3x3:

Cuando aplicamos el kernel a la entrada:

(-1*170)+(0*245)+(1*0)+(2*234)+(1*42)+(2*64)+(1*32)+(-2*53)+ (0*128)=394

Reemplazamos el píxel central con el valor calculado. Luego movemos los granos uno por uno (de arriba a la izquierda a abajo a la derecha) y volvemos a hacer los cálculos.

Nuevamente usamos relleno para los píxeles del borde.

3. Filtrar

        La versatilidad del filtro de imagen se logra a través de su serie de operaciones. Cada operación tiene un propósito diferente, moldeando la belleza de la imagen o facilitando un análisis más profundo.

• filtro suavizante
• filtro de afilado
• filtro de mejora de bordes

3.1 Filtro de suavizado

        Los filtros de suavizado, también conocidos como filtros de desenfoque, tienen la notable capacidad de mejorar la calidad de la imagen al reducir suavemente el ruido, suprimir detalles no deseados y crear una experiencia visual más armoniosa.

        Básicamente, un filtro de suavizado funciona promediando el valor de píxel de una imagen con sus píxeles vecinos. Este proceso de promediado tiene un efecto calmante en la imagen, haciéndola más cohesiva y uniforme. La imagen resultante conserva sus características principales pero limpia las fluctuaciones menores e inconsistencias que podrían oscurecer su esencia.

• caja
• gaussiano
• número mediano

3.2 Desenfoque de fotograma

        Este filtro realiza un promedio simple de los valores de píxeles dentro de una vecindad definida. El tamaño de la vecindad se llama tamaño del núcleo . Cuanto mayor sea el tamaño del núcleo, más borrosa será la imagen.

fuente

Es un filtro suavizante simple y eficiente. A menudo se utiliza como primer paso en algoritmos de procesamiento de imágenes, como la detección de bordes y la reducción de ruido.

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

path = "cath.jpeg"

# read image
image = cv2.imread(path)

# box blur filter
box_blur = cv2.boxFilter(image, -1, (25, 25))

# plot
plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(box_blur, cv2.COLOR_BGR2RGB))
plt.title('Box Blur')
plt.axis('off')

El marco está borroso. Imagen proporcionada por el autor.

El método que utilizamos da como resultado un filtro de promedio simple.boxFiltercv2

cv.boxFilter（src， dprofundidad， ksize[， dst[， anclaje[， normalize[， borderType]]]]） -> dst

• srces la imagen de entrada.
• ddepthes la profundidad deseada de la imagen de salida. Configúrelo en -1 para que la imagen de salida tenga la misma profundidad que la imagen de entrada. De lo contrario, puede utilizar , , .cv2.CV_8Ucv2.CV_16Ucv2.CV_32Fcv2.CV_64F
• ksizees el tamaño del núcleo de la caja. Cuanto más grande sea el grano, más fuerte será el efecto suavizante.
• dstes opcional y genera una imagen. Si no se proporciona, la función creará una nueva imagen de salida.
• anchores un punto de anclaje opcional en el kernel. Generalmente se configura para representar el centro del núcleo. Cambiar esta configuración puede afectar la posición de la salida filtrada.-1, -1
• normalizees un indicador opcional que indica si el kernel debe normalizarse según la cantidad de elementos que contiene. La normalización ayuda a mantener el brillo de la imagen relativamente constante.
• borderTypeEs una bandera opcional que indica cómo manejar los bordes de la imagen.

3.3 filtro gaussiano

        Se necesita un promedio ponderado de los valores de los píxeles, con pesos determinados por una distribución gaussiana. El peso de los píxeles vecinos disminuye a medida que se alejan del píxel central.

        Es un filtro de suavizado más complejo que el desenfoque de cuadro. Preserva mejor los bordes y detalles de las imágenes al tiempo que reduce el ruido.

fuente

gaussian_blur = cv2.GaussianBlur(image, (25, 25), 0)

plt.figure(figsize=(10, 8))

plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(gaussian_blur, cv2.COLOR_BGR2RGB))
plt.title('Gaussian Blur')
plt.axis('off')

Desenfoque gaussiano. Imagen proporcionada por el autor.

cv.GaussianBlur（src， ksize， sigmaX[， dst[， sigmaY[， borderType]]]） -> dst

• sigmaXes la desviación estándar del núcleo gaussiano en la dirección horizontal. Cuanto mayor sea el valor, más fuerte será el efecto de desenfoque.
• sigmaYEs opcional, la desviación estándar del núcleo gaussiano en la dirección vertical. Si no se especifica, el valor predeterminado es el mismo que .sigmaX

3.4 Filtro de mediana

El filtro de mediana reemplaza cada valor de píxel de la imagen con el valor de la mediana de sus píxeles vecinos. La mediana es el valor medio en una lista ordenada de valores. Esto significa que el filtro mediano no se ve afectado por valores atípicos como picos de ruido.

fuente

median_filtered = cv2.medianBlur(image, 25)

plt.figure(figsize=(10, 8))

plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title( 'Original Image' )
plt.axis( 'off' )

plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(median_filtered, cv2.COLOR_BGR2RGB))
plt.title( 'Median Filter' )
plt.axis( 'off'  )

Filtro mediano. Imagen proporcionada por el autor.

cv.medianBlur（src，ksize[，dst]） -> dst

4. Filtro de afilado

        Los filtros de nitidez son un tipo de técnica de procesamiento de imágenes que se utiliza para mejorar los bordes y los detalles finos de las imágenes. A diferencia de los filtros de desenfoque, que suavizan los detalles de la imagen, los filtros de nitidez resaltan las diferencias en la intensidad de los píxeles entre áreas adyacentes, mejorando así los bordes y haciendo que las características sean más prominentes.

        El filtro de nitidez funciona mejorando los componentes de alta frecuencia de una imagen. Los componentes de alta frecuencia corresponden a cambios rápidos en los valores de los píxeles, que son característicos de los bordes y los detalles finos.

        Los filtros de nitidez pueden producir efectos visualmente atractivos, pero deben usarse con precaución. Un enfoque excesivo puede amplificar el ruido e introducir artefactos. A menudo es una buena práctica aplicar un filtro de nitidez a una imagen que ya es de buena calidad y tiene un ruido mínimo.

• filtro laplaciano
• Máscara de enfoque

4.1 Filtro laplaciano

El filtro laplaciano es un filtro de detección de bordes que se utiliza en el procesamiento de imágenes. Es un filtro de segunda derivada, lo que significa que mide la tasa de cambio de la intensidad de la imagen. Los filtros laplacianos se utilizan comúnmente para enfocar imágenes y detectar bordes.

fuente

laplacian = cv2.Laplacian(image, -1, ksize=5, scale=1,delta=0,borderType=cv2.BORDER_DEFAULT)

plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(laplacian)
plt.title('Laplacian Filter')
plt.axis('off')

Filtro laplaciano. Imagen proporcionada por el autor.

cv.Laplacian（src， dprofundidad[， dst[， ksize[， escala[， delta[， borderType]]]]]） -> dst

• ksizees opcional, el tamaño del kernel que se utilizará para las operaciones laplacianas. Se establece en un número impar, como,,, etc. Si no se proporciona, el valor predeterminado es el que corresponde a un núcleo de 3x3.1351
• scalees opcional y es el factor de escala aplicado al valor laplaciano calculado. Este parámetro ayuda a potenciar o reducir el efecto del laplaciano.
• deltaes opcional y es un valor para agregar al valor laplaciano calculado. Se puede utilizar para controlar el brillo o el contraste general de la salida.

4.2 Máscara de enfoque

        Implica crear una versión borrosa de la imagen original (usando un filtro de paso bajo) y luego restar esta versión borrosa de la imagen original. El resultado es una imagen con bordes y detalles resaltados. El término "desenfocar" se refiere a la creación de una máscara que resalta el contenido desenfocado de la imagen.

fuente

        La cantidad de nitidez está controlada por la cantidad de desenfoque y el peso de la imagen borrosa. El desenfoque suele ser un desenfoque gaussiano, pero también se pueden utilizar otros tipos de desenfoque. Las imágenes borrosas suelen tener pesos entre 0 y 1. Un mayor peso dará como resultado un mayor afilado.

blurred = cv2.GaussianBlur(image, (25, 25), 3)
k = 3
unsharp_mask = cv2.addWeighted(image, k-1, blurred, -1.0, 0)

plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(unsharp_mask, cv2.COLOR_BGR2RGB))
plt.title('Unsharp Masking')
plt.axis('off')

Enmascaramiento de enfoque. Imagen proporcionada por el autor.

        El filtrado de alto impulso es una forma común de enmascaramiento de enfoque. Le permite controlar la cantidad de mejora aplicada a los detalles de la imagen. Para ello, agrega una combinación ponderada de la imagen original y una versión borrosa de la imagen, donde el peso determina el grado de mejora.

        Esta función se utiliza para combinar dos imágenes con diferentes pesos. En este contexto, se utiliza para realizar operaciones de filtrado de alto impulso.cv2.addWeighted

• image: Esta es la imagen original.
• k - 1: Este es el peso de la imagen original. Restar 1 de esto asegura que la contribución de la imagen original se escala de acuerdo con el factor de mejora. Value pone más énfasis en los detalles mejorados.kk - 1
• blurred: Esta es una imagen borrosa.
• -0.5: Este es el peso de la imagen borrosa. Los valores negativos restan desenfoque a la imagen.
• 0: Este es un valor de compensación. Después de la suma ponderada, se suma al resultado.

5. Filtro de mejora de bordes

        El filtro de mejora de bordes es un filtro de imagen que se utiliza para mejorar los bordes de una imagen. Los bordes son los límites entre diferentes regiones de una imagen y son importantes para proporcionar información sobre la estructura y forma de los objetos de la imagen.

• filtro sobel
• Filtro prehumedecido
• Laplaciano filtrado gaussiano
• Detector de bordes inteligente

5.1 Filtro Sobel

        El filtro Sobel se utiliza para detectar bordes calculando el gradiente de intensidad de la imagen en cada píxel. Utiliza dos núcleos de convolución separados (uno para la dirección horizontal y otro para la dirección vertical) para aproximar el gradiente.

Operador Sobel. fuente

        El filtro Sobel es un filtro de detección de bordes popular porque es relativamente sencillo de implementar y muy eficaz para detectar bordes. Sin embargo, también puede ser sensible al ruido, por lo que se suele utilizar junto con otros filtros como el Desenfoque Gaussiano para reducir el ruido en la imagen antes de aplicar el filtro Sobel.

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Apply Sobel Filter
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=25)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=25)
sobel_edges = np.sqrt(sobel_x**2 + sobel_y**2)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(sobel_edges, cmap='gray')
plt.title('Sobel Filter')
plt.axis('off')

Filtro Sobel. Imagen proporcionada por el autor.

cv.Sobel（src， dprofundidad， dx， dy[， dst[， ksize[， escala[， delta[， borderType]]]]]） -> dst

• dxy: el orden de las derivadas en las direcciones x e y respectivamente. Estos valores determinan la dirección en la que se calcula el gradiente. Por ejemplo, establezca y calcule el gradiente en la dirección x.dydx=1dy=0
• ksize(opcional): el tamaño del núcleo de Sobel utilizado para los cálculos. Por lo general, se establece en un número impar, como,,, etc. Si no se proporciona, el valor predeterminado es el que corresponde a un núcleo de 3x3.1353
• scale(Opcional): Factor de escala que se aplicará a los valores de Sobel calculados. Este parámetro ayuda a aumentar o disminuir el efecto del operador Sobel.
• delta(Opcional): Valor para agregar al valor de Sobel calculado. Se puede utilizar para controlar el brillo o el contraste general de la salida.

5.2 Filtro prehumedecido

Similar al filtro Sobel, el filtro Prewitt también calcula el gradiente de intensidad de la imagen para detectar bordes. Utiliza un núcleo más simple que el de Sobel, pero sigue siendo eficaz para resaltar los bordes.

• La intensidad del filtro debe ajustarse cuidadosamente para evitar una imagen demasiado nítida.
• Si es posible, el filtro debe aplicarse a una versión de la imagen sin ruido.
• Los filtros deben usarse junto con otras técnicas de procesamiento de imágenes (como el suavizado) para mejorar la calidad general de la imagen.

Operador prewett. fuente

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Prewitt Filter
kernel_x = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])
kernel_y = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]])

prewitt_x = cv2.filter2D(image, cv2.CV_64F, kernel_x)
prewitt_y = cv2.filter2D(image, cv2.CV_64F, kernel_y)
prewitt_edges = np.sqrt(prewitt_x**2 + prewitt_y**2)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(prewitt_edges, cmap='gray')
plt.title('Prewitt Filter')
plt.axis('off')

Filtro prehumedecido. Imagen proporcionada por el autor.

5.3 Laplaciano de filtrado gaussiano

        El filtro LoG combina los efectos de desenfoque y detección de bordes. Primero aplica el desenfoque gaussiano a la imagen y luego calcula el operador laplaciano en la imagen borrosa. El resultado es que se realzan los bordes de la imagen y se suprime el ruido.

Filtro laplaciano de Gauss. fuente

        El filtro LoG es un filtro separable, lo que significa que se puede calcular convolucionando la imagen con un único núcleo (es decir, una matriz de 3x3). El núcleo consta de pesos diseñados para mejorar los bordes de la imagen.

• La intensidad del filtro debe ajustarse cuidadosamente para evitar una imagen demasiado nítida.
• Si es posible, el filtro debe aplicarse a una versión de la imagen sin ruido.
• Los filtros deben usarse junto con otras técnicas de procesamiento de imágenes (como el suavizado) para mejorar la calidad general de la imagen.

image = cv2.imread(path, cv2.IMREAD_GRAYSCALE)

# Apply Laplacian of Gaussian (LoG) Filter
log_edges = cv2.Laplacian(image, cv2.CV_64F)
log_edges = cv2.convertScaleAbs(log_edges)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(log_edges, cmap='gray')
plt.title('LoG Filter')
plt.axis('off')

Filtro de registro. Imagen proporcionada por el autor.

La operación laplaciana puede generar valores tanto positivos como negativos, que pueden no ser adecuados para la visualización. La función se utiliza para convertir la salida de la operación laplaciana a un valor absoluto y luego a un tipo de datos más adecuado para la visualización de imágenes ().cv2.convertScaleAbs(log_edges)uint8

5.4 Detector de bordes inteligente

        El detector de bordes Canny es una técnica popular de procesamiento de imágenes que se utiliza para detectar bordes en imágenes.

Detector de bordes inteligente. fuente

Los detectores de bordes Canny funcionan identificando áreas en una imagen con intensidad que cambia rápidamente, que a menudo corresponden a límites de objetos o características importantes.

La salida del detector de bordes Canny es una imagen binaria donde los píxeles de los bordes están marcados con blanco y los píxeles sin bordes con negro. La técnica es versátil y se puede perfeccionar ajustando parámetros como la desviación estándar del desenfoque gaussiano y el umbral de detección de bordes.

canny_edges = cv2.Canny(image, 30, 60)

# plot
plt.figure(figsize=(12, 8))
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 3, 2)
plt.imshow(canny_edges, cmap='gray')
plt.title('Canny Edge Filter')
plt.axis('off')

Filtro de borde inteligente. Imagen proporcionada por el autor.

cv.Canny(Imagen, Umbral1, Umbral2[, Bordes[, Tamaño de apertura[, L2Gradient]]]) -> Bordes

cv.Canny（dx， dy， umbral1， umbral2[， bordes[， L2gradient]]） -> borde

• image: La imagen de entrada a la que se aplicará la detección de bordes Canny. Suele ser una imagen en escala de grises.
• threshold1y: Estos son los umbrales inferior y superior utilizados en el paso de umbral dual. El algoritmo Canny marca los píxeles con magnitudes de gradiente superiores como bordes fuertes y los píxeles entre los bordes como bordes débiles. Los píxeles siguientes se consideran sin bordes y se descartarán.threshold2threshold2threshold1threshold2threshold1
• apertureSize(Opcional): el tamaño del kernel de Sobel utilizado para los cálculos de gradiente. Generalmente está configurado en , o . Si no se proporciona, el valor predeterminado es.3573
• L2gradient(opcional): indicador que indica si se debe utilizar la norma L2 para calcular la magnitud del gradiente. Si , entonces use la distancia euclidiana. Si , se utiliza la norma L1. El valor predeterminado es .TrueFalseFalse

        En esencia, el filtrado de imágenes consiste en extraer información oculta de los datos de píxeles. A través del poder matemático de la convolución, mejora los bordes, reduce el ruido y transforma imágenes en bruto en historias atractivas. Este proceso combina propósito con tecnología, solidificando la poderosa capacidad del filtrado de imágenes para revelar lo invisible y mejorar la percepción visual. Okan Jernigan

·