Implementar un filtro de paso alto usando Python

Un filtro de paso alto es un filtro que restringe el movimiento de señales que son más bajas que una frecuencia de umbral predefinida o un corte. La señal con frecuencias mayores o iguales al umbral pasa a través del filtro sin obstrucciones. Esta acción atenúa las señales con bajas frecuencias. Un filtro de paso alto filtra los ruidos no deseados, como los sonidos.

En este artículo, aprenderemos cómo implementar un filtro de paso alto usando Python.

Implementar filtro de paso alto usando Python

La implementación del filtro de paso alto utiliza 4 módulos de Python, a saber, numpy, pandas, scipy y matplotlib.

El módulo numpy es un módulo robusto de Python rico en utilidades para trabajar con grandes matrices y arreglos multidimensionales. Estas utilidades ayudan a realizar operaciones matemáticas sencillas y complejas sobre matrices sin problemas. Estas utilidades están optimizadas y altamente dinámicas para las entradas.

Para instalar la última versión del módulo numpy, utilice cualquiera de los siguientes comandos pip.

pip install numpy
pip3 install numpy

El módulo pandas es un potente y flexible módulo de análisis y manipulación de datos de código abierto escrito en Python.

Para instalar el módulo pandas, utilice cualquiera de los siguientes comandos pip.

pip install pandas
pip3 install pandas

El módulo scipy es un módulo Python de código abierto para computación científica y técnica.

Para instalar el módulo scipy, utilice cualquiera de los siguientes comandos pip.

pip install scipy
pip3 install scipy

Y, el módulo matplotlib es una biblioteca de Python completa y optimizada para la visualización gráfica de datos.

Para instalar la última versión del módulo matplotlib, utilice cualquiera de los siguientes comandos pip.

pip install matplotlib
pip3 install matplotlib

Ahora que hemos terminado con breves introducciones sobre las bibliotecas, veamos el código de Python para el filtro de paso alto.

import numpy as np
import pandas as pd
from scipy import signal
import matplotlib.pyplot as plt


def sine_generator(fs, sinefreq, duration):
    T = duration
    n = fs * T
    w = 2.0 * np.pi * sinefreq
    t_sine = np.linspace(0, T, n, endpoint=False)
    y_sine = np.sin(w * t_sine)
    result = pd.DataFrame({"data": y_sine}, index=t_sine)
    return result


def butter_highpass(cutoff, fs, order=5):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = signal.butter(order, normal_cutoff, btype="high", analog=False)
    return b, a


def butter_highpass_filter(data, cutoff, fs, order=5):
    b, a = butter_highpass(cutoff, fs, order=order)
    y = signal.filtfilt(b, a, data)
    return y


fps = 30
sine_fq = 10
duration = 10
sine_5Hz = sine_generator(fps, sine_fq, duration)
sine_fq = 1
duration = 10
sine_1Hz = sine_generator(fps, sine_fq, duration)
sine = sine_5Hz + sine_1Hz
filtered_sine = butter_highpass_filter(sine.data, 10, fps)
plt.figure(figsize=(20, 10))
plt.subplot(211)
plt.plot(range(len(sine)), sine)
plt.title("Generated Signal")
plt.subplot(212)
plt.plot(range(len(filtered_sine)), filtered_sine)
plt.title("Filtered Signal")
plt.show()

En el código anterior, la frecuencia sinusoidal o el valor sine_fq debe estar en Hertz o Hz, y la duración o duration debe estar en segundos o sec. La señal generada es la señal original y la señal filtrada es la señal formada debido al filtro de paso alto. El gráfico generado muestra las diferencias entre los dos.