En este artículo, discutiremos cómo implementar la imagen del filtro de paso alto (HPF) de Photoshop en Python OpenCV .
Filtro de paso alto
Cuando hablamos de procesamiento digital de señales o procesamiento digital de imágenes, los filtros son el concepto más fundamental. Se utiliza un filtro o un filtro digital para filtrar la respuesta de frecuencia no deseada de las señales. Se puede usar un filtro para cumplir con dos tareas principales en el procesamiento de señales digitales: la separación de señales y la restauración de señales. La separación de señales es básicamente una separación de ruido y una atenuación de ruido de las señales de entrada. Este proceso se utiliza principalmente en EKG, un monitor de electrocardiograma para filtrar la respiración y los latidos del corazón de la madre. La restauración de la señal es un proceso cuando la señal de entrada se distorsiona de alguna manera. Esto se utiliza principalmente para desenfocar una imagen. Veremos para qué se utiliza principalmente el filtro de paso alto.
Se utiliza una ventaja principal del filtro de paso alto (HPF) para agudizar la imagen atenuando la baja frecuencia. Cuando la respuesta de impulso o la señal pasan a través de un filtro de paso alto, un HPF permite principalmente que pasen las frecuencias altas. Como se utilizan filtros de paso alto para agudizar las imágenes, la frecuencia obtenida es menor en comparación con la frecuencia de corte (ωc). En OpenCV y en el procesamiento de imágenes digitales también usamos la funcionalidad HPF para encontrar los bordes de una imagen.
Método 1: filtro de paso alto (HPF) en Python OpenCV
Aquí vamos a realizar HPF usando OpenCV en Python
Imágenes usadas:
Ahora que tenemos una imagen, usando el módulo OpenCV de Python vamos a leer la imagen.
img = cv2.imread(“outimage.(jpeg/png/jpg)”)
Dado el tamaño de la imagen, también podemos cambiar el tamaño de la forma, este paso es completamente opcional. Mientras cambia el tamaño de la imagen, puede pasar una interpolación para que la imagen mantenga su calidad. Puede elegir libremente los métodos cv2.INTER_BITS, cv2.INTER_CUBIC o cv2.INTER_LINEAR para cambiar el tamaño de la interpolación.
img = cv2.resize(img,(ancho,alto),interpolación=cv2.INTER_BITS)
El siguiente paso es desenfocar la imagen. La razón para desenfocar la imagen es agregar un efecto de suavizado a una imagen. Al desenfocar la imagen podemos filtrar el ruido no deseado de la imagen. En la biblioteca OpenCV, usamos ampliamente el filtro gaussiano. Emplea la técnica «convolución del núcleo».
Nota: 127 se agrega después de restar la imagen con una imagen borrosa para agregar el aspecto grisáceo. Usaremos Gaussian Blur para desenfocar la imagen.
hpf = img – cv2.GaussianBlur(img,(21,21),3)+127
Implementación
Python3
import cv2
img = cv2.imread("naruto.jpg")
img = cv2.resize(img, (680, 520),
interpolation=cv2.INTER_CUBIC)
# subtract the original image with the blurred image
# after subtracting add 127 to the total result
hpf = img - cv2.GaussianBlur(img, (21, 21), 3)+127
# display both original image and filtered image
cv2.imshow("Original", img)
cv2.imshow("High Passed Filter", hpf)
# cv2.waitkey is used to display
# the image continuously
# if you provide 1000 instead of 0 then
# image will close in 1sec
# you pass in milli second
cv2.waitKey(0)
cv2.destroyAllWindows()
Producción:
Método 2: Usando Sobel y Laplaciano
Python OpenCV es compatible con la implementación de Sobel y Laplacian.
Sintaxis para Laplacian: laplacian=cv2.Laplacian(gray,cv2.CV_64F)
Sintaxis para SobelX: [dx=1 y dy=0]: sobelx=cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=7)
Sintaxis para SobelY: [dx=0 y dy=1]: sobely=cv2.Sobel(gray,cv2.CV_64F,dx=0,dy=1,ksize=7)
Nota: cv2.CV_64F denota la profundidad de la imagen
Python3
import cv2
import numpy as np
import matplotlib.pyplot as plt
# read image
img = cv2.imread("naruto.jpeg")
# resize image
img = cv2.resize(img, (500, 450), interpolation=cv2.INTER_CUBIC)
# convert image to gray scale image
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# apply laplacian blur
laplacian = cv2.Laplacian(gray, cv2.CV_64F)
# sobel x filter where dx=1 and dy=0
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=7)
# sobel y filter where dx=0 and dy=1
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=7)
# combine sobel x and y
sobel = cv2.bitwise_and(sobelx, sobely)
# plot images
plt.subplot(2, 2, 1)
plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian')
plt.subplot(2, 2, 2)
plt.imshow(sobelx, cmap='gray')
plt.title('SobelX')
plt.subplot(2, 2, 3)
plt.imshow(sobely, cmap='gray')
plt.title('SobelY')
plt.subplot(2, 2, 4)
plt.imshow(sobel, cmap='gray')
plt.title('Sobel')
plt.show()
cv2.waitKey(0)
cv2.destroyAllWindows()
Producción:
Método 3: realizar manualmente el filtro de paso alto en la imagen
Como ya hemos definido el método de array, filtremos manualmente los datos de nuestra imagen. Al mantener una referencia de la array laplaciana, mostremos el formato de array de píxeles de una imagen después del enmascaramiento HPF.
Python3
import cv2
import numpy as np
img = cv2.imread('naruto.jpeg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# dimension of gray image is in 2D
dimensions = gray.shape # (height,weight)
print("Image Dimensions:", dimensions)
n = int(input("Enter the size of the original image to be captured:"))
print("The matrix of the original image:")
for i in range(0, n):
for j in range(0, n):
print(gray[i][j], end=" ")
print()
"""
Apply below filter on image matrix
0 -1 0
-1 4 -1
0 -1 0
"""
filter = np.zeros(shape=(n, n))
for i in range(0, n):
for j in range(0, n):
filter[i][j] = 0*gray[i][j]-1*gray[i][j+1]\
+0*gray[i][j+2]-1*gray[i+1][j]+4 * \
gray[i+1][j+1]-1*gray[i+1][j+2]+0*gray[i+2][j] - \
1*gray[i+2][j+1]+0*gray[i+2][j+2]
print("\n")
print("The matrix form after HPF masking the captured image is:")
print("\n")
for hpf in filter:
print(hpf)
cv2.imshow("Image", gray)
cv2.waitKey(0)
cv2.destroyAllWindows()
Producción:
