Requisitos previos: conceptos básicos de OpenCV , conceptos básicos de convolución
En este artículo, se analiza el filtrado de imágenes mediante convolución en OpenCV (Open Source Computer Vision). Para utilizar la biblioteca OpenCV en Python, se deben instalar las siguientes bibliotecas como requisito previo:
- biblioteca numpy
- biblioteca matplotlib
- Biblioteca OpenCV
Para instalar las siguientes bibliotecas, ejecute los siguientes comandos en el símbolo del sistema:
pip install opencv-python pip install numpy pip install matplotlib
Convolución 2-D
La operación fundamental y más básica en el procesamiento de imágenes es la convolución. Esto se puede lograr mediante el uso de Kernels. El núcleo es una array que generalmente es más pequeña que la imagen y el centro de la array del núcleo coincide con los píxeles.
En una convolución 2D, la array kernel es una array bidimensional, cuadrada, A x B, donde tanto A como B son números enteros impares.
La posición de la imagen de salida se obtiene multiplicando cada valor de la array por el valor correspondiente de la array de la imagen y luego sumándolos. En función de estas operaciones realizadas, se pueden realizar varios efectos como desenfoque y nitidez de las imágenes.
Núcleo de identidad
Identity Kernel es la operación de kernel más simple y básica que se puede realizar. La imagen de salida producida es exactamente igual a la imagen que se da como entrada. Cambia la imagen de entrada. Es una array cuadrada con el elemento central igual a 1. Todos los demás elementos de la array son 0. El código que se proporciona a continuación demuestra el funcionamiento de Identity Kernel:
Imagen utilizada:
Python3
# Importing OpenCV and Numpy Librariesimport cv2import numpy as np # Reads image from the disk using cv2.imread() function img = cv2.imread('geeksforgeeks.png') # Apply identity kernel# In an Identity Kernel matrix the value of the middle element is 1# The values of all the other elements are 0id_kernel = np.array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) # Filtered image is obtained using the variable flt_img# cv2.fliter2D() is the function used# src is the source of image(here, img)# ddepth is destination depth. -1 will mean output image will have same depth as input image# kernel is used for specifying the kernel operation (here, id_kernel)flt_img = cv2.filter2D(src=img, ddepth=-1, kernel=id_kernel) # Display the filtered image using cv2.imshow() function# Here, output image is same as input image since we are using identity kernelcv2.imshow('Identity', flt_img) # cv2.waitkey(delay) function holds the screen till any key is pressed by the user# It pauses the screen for delay milliseconds if the delay is a positive value# It pauses the screen for a key event infinitely if the delay is 0 or negativecv2.waitKey(0) # cv2.destroyAllWindows() function deletes all the GUI windows from memorycv2.destroyAllWindows() |
Producción :
Borrón
El desenfoque se define como promediar los valores del píxel dentro de un vecindario. Este efecto de promedio suaviza o difumina los bordes afilados. También se dice que el efecto de desenfoque tiene un efecto de ‘filtro de paso bajo’ porque solo permite que las frecuencias bajas (baja tasa de cambio de píxeles) entren a través de él.
Pasos involucrados en desenfocar una imagen:
- Elija el tamaño del núcleo sobre un píxel (p). Cuanto mayor sea el tamaño del grano, mayor será el efecto suavizante. Esto se debe a que los núcleos grandes producen valores promedio grandes con respecto a los píxeles vecinos y, por lo tanto, dan como resultado una gran cantidad de suavizado.
- Multiplique cada valor del núcleo con el valor correspondiente de la array de la imagen.
- Sume los resultados de las multiplicaciones y calcule el promedio y obtenga la Resultante.
- Por último, reemplace el valor del píxel (p) con los resultados obtenidos.
Caja de desenfoque:
Esto se obtiene promediando uniformemente los valores en la vecindad. Es un desenfoque directo. Se representa de la siguiente manera:
Los valores deben sumarse hasta 1. Es por eso que dividimos la array por 9. Esto se llama Normalización. A continuación se muestra el código para demostrar el efecto de desenfoque de cuadro:
Python3
# Importing the OpenCV, Numpy and Mat librariesimport cv2import numpy as npimport matplotlib.pyplot as plt # Reading the image from the disk using cv2.imread() function# Showing the original image using matplotlib library function plt.imshow()img = cv2.imread('geeksforgeeks.png')plt.imshow(img)plt.show() # Kernel for box blur filter# It is a unity matrix which is divided by 9 box_blur_ker = np.array([[0.1111111, 0.1111111, 0.1111111], [0.1111111, 0.1111111, 0.1111111], [0.1111111, 0.1111111, 0.1111111]]) # Applying Box Blur effect# Using the cv2.filter2D() function# src is the source of image(here, img)# ddepth is destination depth. -1 will mean output image will have same depth as input image# kernel is used for specifying the kernel operation (here, box_blur_ker)Box_blur = cv2.filter2D(src=img, ddepth=-1, kernel=box_blur_ker) # Showing the box blur image using matplotlib library function plt.imshow()plt.imshow(Box_blur)plt.show() |
Producción :
Desenfoque gaussiano:
Este filtro se puede obtener encontrando el promedio ponderado del píxel. Los pesos de los píxeles se calculan en función de la distancia desde el centro del kernel. Los píxeles más cercanos al centro del núcleo influyen más en el promedio ponderado.
El filtro gaussiano requiere 2 especificaciones: desviación estándar en el eje X y desviación estándar en el eje Y, representadas como sigmaX y sigmaY respectivamente. Si ambos se establecen en 0, se toma el tamaño del kernel para calcular la desviación estándar.
El código que se proporciona a continuación demuestra el filtro de desenfoque gaussiano:
Python3
# Importing the OpenCV, Numpy and Matplotlib librariesimport cv2import numpy as npimport matplotlib.pyplot as plt # Reading the image from the disk using cv2.imread() function# Showing the original image using matplotlib library function plt.imshow()img = cv2.imread('geeksforgeeks.png')plt.imshow(img)plt.show() # Applying Gaussian Blur Filter using cv2.GaussianBlur() function# src is the source of image(here, img)# ksize is the size of kernel in the form A x B (here 3 x 3)# sigmaX is standard deviation of X axis# sigmaY is the standard deviation of Y axis# Since sigmaX and sigmaY is 0, the standard deviation the size of kernelgaussian_blur = cv2.GaussianBlur(src=img, ksize=(3,3),sigmaX=0, sigmaY=0) # Showing the Gaussian blur image using matplotlib library function plt.imshow()plt.imshow(gaussian_blur)plt.show() |
Producción :
Desenfoque medio:
El efecto de filtrado Median Blur se obtiene cuando cada valor de píxel se reemplaza con el valor medio de los píxeles de la imagen en la vecindad.
El código que se proporciona a continuación demuestra Median Blur:
Python3
# Importing the OpenCV, Numpy and Matplotlib librariesimport cv2import numpy as npimport matplotlib.pyplot as plt # Reading the image from the disk using cv2.imread() function# Showing the original image using matplotlib library function plt.imshow()img = cv2.imread('geeksforgeeks.png')plt.imshow(img)plt.show() # Applying median Blur Filter using cv2.medianBlur() function# src is the source of image(here, img)# ksize is the size of kernel. Should have a positive odd valuemedian_blur = cv2.medianBlur(src=img, ksize=9) # Showing the Median blur image using matplotlib library function plt.imshow()plt.imshow(median_blur)plt.show() |
Producción :
Afilado
La nitidez de la imagen ayuda a mejorar los bordes y hacerlos nítidos. Este filtro ayuda a perfilar los bordes y hacer que la imagen se vea prominente. Las características de la imagen se ven distintivas al usar este filtro.
Usamos un kernel 2D personalizado para aplicar esta técnica de filtrado. El siguiente núcleo se puede utilizar para agudizar la imagen:
El código que se proporciona a continuación demuestra el uso del filtro de nitidez:
Python3
# Importing the OpenCV, Numpy and Matplotlib librariesimport cv2import numpy as npimport matplotlib.pyplot as plt # Reading the image from the disk using cv2.imread() function# Showing the original image using matplotlib library function plt.imshow()img = cv2.imread('geeksforgeeks.png')plt.imshow(img)plt.show() # Apply kernel for sharpeningsharp_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) # Sharpeneded image is obtained using the variable sharp_img# cv2.fliter2D() is the function used# src is the source of image(here, img)# ddepth is destination depth. -1 will mean output image will have same depth as input image# kernel is used for specifying the kernel operation (here, sharp_kernel)sharp_img = cv2.filter2D(src=img, ddepth=-1, kernel=sharp_kernel) # Showing the sharpened image using matplotlib library function plt.imshow()plt.imshow(sharp_img)plt.show() |
Producción :
Realzar
La formación de un diseño 3D que sobresale de la superficie se llama Emboss. Reemplaza el píxel con una sombra o un resaltado.
La siguiente array de kernel se puede usar para aplicar al filtro de relieve:
El siguiente código demuestra la aplicación del filtro de relieve:
Python3
# Importing the OpenCV, Numpy and Matplotlib librariesimport cv2import numpy as npimport matplotlib.pyplot as plt # Reading the image from the disk using cv2.imread() function# Showing the original image using matplotlib library function plt.imshow()img = cv2.imread('geeksforgeeks.png')plt.imshow(img)plt.show() # Apply kernel for embossingemboss_kernel = np.array([[-1, 0, 0], [0, 0, 0], [0, 0, 1]]) # Embossed image is obtained using the variable emboss_img# cv2.fliter2D() is the function used# src is the source of image(here, img)# ddepth is destination depth. -1 will mean output image will have same depth as input image# kernel is used for specifying the kernel operation (here, emboss_kernel)emboss_img = cv2.filter2D(src=img, ddepth=-1, kernel=emboss_kernel) # Showing the embossed image using matplotlib library function plt.imshow()plt.imshow(emboss_img)plt.show() |
Producción :
