Análisis de Señales Biológicas

Josué Alejandro Alemán Vilis

Proyecto 4

DETECCION DE SEÑALES

________________________________________
El Algoritmo de Pan-Tompkins para la detección del complejo QRS

Pan and Tompkins propusieron un algoritmo para la detección del complejo QRS en
tiempo real basado en el análisis de la pendiente, amplitud y anchura de los
complejos QRS. El algoritmo incluye una serie de filtros y métodos pasa bajas, pasa
altas, derivadas, operaciones al cuadrado, integración, umbral adaptativo, y
búsqueda de procedimientos. La figura 1 ilustra los pasos del algoritmo en forma
esquemática.

Filtro pasa Operacion

Diferenciador Integrador
bandas cuadratica

Figura 1. Diagrama de boques del algoritmo Pan Tompkins para la detección QRS

Las etapas del algoritmo son:

1. Filtrado pasa-banda: compuesto por un pasa-alto y pasa-bajo en cascada,

que atenúa las bajas frecuencias características de las ondas P y T, así como
de las oscilaciones basales, y también atenúa las frecuencias altas del EMG
y la interferencia de red.
2. Derivación: destaca las pendientes rápidas de la señal, que coinciden en el
caso del ECG con el QRS.
3. Transformación no lineal: eleva al cuadrado la señal, convirtiéndola en
positiva antes de la integración, y acentuando también las frecuencias altas,
que corresponden al QRS.
 4. Promediación: puesto que complejos anormales con amplitudes y pendientes
iguales o mayores que los QRS, como es el caso de los PVC, pueden ser
detectados como QRS normales, se utiliza un promediador de ventana móvil
para obtener la duración del complejo detectado, ya que los PVC suelen
presentar duraciones mayores que los QRS normales. La ecuación del
promediador viene dada por:

𝑦 (𝑛) = [𝑥(𝑛 − (𝑁 − 1)) + 𝑥(𝑛 − (𝑁 − 2)) + ⋯ + 𝑥(𝑛)]/𝑁

donde N es el número de muestras de la ventana. La anchura de la ventana

debe tomarse de manera que contenga los complejos QRS normales o
anómalos, sin llegar a incluir la onda T. El algoritmo fija este valor en 150 ms.
Se definen dos tipos de umbrales, que permiten diferenciar si la detección
corresponde a un QRS o a ruido (onda T, EMG, etc.). Cada vez que se
detecta un QRS o ruido, los correspondientes umbrales se actualizan con el
nuevo valor, por lo que el algoritmo se adapta a los cambios del ECG para
cada paciente en particular. Además, si se produce un fallo de detección (un
QRS no es detectado porque el umbral en ese instante es demasiado alto),
el algoritmo implementa una técnica de “búsqueda atrás”. Para ello, se debe
mantener información de la separación normal entre pulsos consecutivos y,
si se supera ésta, se vuelve a analizar el tramo anterior con un umbral menor.

El algoritmo utiliza un histórico del valor promedio de los últimos 8 intervalos RR

normales, y cada vez que se detecta un nuevo QRS se compara el último RR con
el promedio. Si está dentro de rango, se actualiza el promedio. Si está fuera de
rango, se activa la búsqueda atrás.

Proyecto

Implementa el método de Pan Tompkins para la detección QRS en MATLAB. Aplica

el procedimiento a la señales de los archivos ECG3.dat, ECG4.dat, ECG5.dat, y
ECG6.dat. Muestreados a una tasa de 200 Hz. Determina el ritmo cardiaco para
cada uno de los eventos. Verifica tus resultados midiendo los parámetros
visualmente de los plots de cada una de las señales.
A continuación, se muestran las figuras que muestran los ECG analizados, con cada
uno de los respectivos pasos del algoritmo.

Fig 2. Resultado del algoritmo Pan Tompkins para los datos de ECG3.

Fig 3. Resultado del algoritmo Pan Tompkins para los datos de ECG4.
 Fig 4. Resultado del algoritmo Pan Tompkins para los datos de ECG5.

Fig 5. Resultado del algoritmo Pan Tompkins para los datos de ECG6.

En la siguiente tabla se muestran las comparaciones de los BPM obtenidos con el

método de detección Pan Tompkins y los medido visualmente.

Señal de ECG BPM por detección BPM inspección visual

ECG 3 78 72
ECG 4 99 96
ECG 5 138 132
ECG 6 54 54
Como se logra observar en la tabla anterior, hay una diferencia entre los valores de
BPM encontrados con el método de detección de Pan Tompkins y aquellos
determinados estudiando visualmente las señales de ECG. Aún así la diferencia no
es mucho mayor a 6 BPM y en el caso del ECG6 ambas observaciones coincidieron.

Estas diferencias podrían deberse al “delay” que se da por el filtrado de las señales,
por el método en sí, o por el ruido en las señales. Es por este tipo de errores que la
prueba de oro sigue siendo la inspección visual de las señales ECG.
ANEXO Codigo en Matlab

clear all
clc
load 'ECG3.dat'
load 'ECG4.dat'
load 'ECG5.dat'
load 'ECG6.dat'

fs=200;
ecg = ECG3;
t=[1:length(ecg)]/fs;
gr = 1;

figure (1)
subplot (5,1,1);
ecg = ecg/ max( abs(ecg));
plot(t,ecg);

title ('ECG Ruidoso')

%Filtro pasa bajas

b = [1 0 0 0 0 0 -2 0 0 0 0 0 1];
a = [1 -2 1];
h_l = filter(b,a, ecg); %señal que se quiere filtrar
ecg_l = conv (ecg ,h_l);
ecg_l = ecg_l/ max( abs(ecg_l));

%Filtro pasa altas

b = [-1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 32 -32 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1];
a = [1 -1];
h_h = filter(b,a, h_l);
ecg_h = conv (ecg_l ,h_h);
ecg_h = ecg_h/ max( abs(ecg_h));

%Filtro pasa bandas

fs = 200; %Frecuencia de muestreo
f1=5; %Frecuencia de corte-baja
f2=15; %Frecuencia de corte_alta
Wn=[f1 f2]*2/fs;
N = 3; % orden del filtro
[a,b] = butter(N,Wn);

ecg_h = filtfilt(a,b,ecg);
ecg_h = ecg_h/ max( abs(ecg_h));

subplot (5,1,2);
plot (t, ecg_h);
title ('ECG Filtrado');

%Derivative operator
h_d = [-1 -2 0 2 1]*(1/8);%1/8*fs
ecg_d = conv (ecg_h ,h_d);
ecg_d = ecg_d/max(ecg_d);
ecg_d([4001: 4004],:)=[]
subplot (5,1,3);
plot (t, ecg_d);
title ('ECG Derivado');

%elevar al cuadrado
ecg_s = ecg_d.^2;
subplot (5,1,4);
plot (t, ecg_s);
title ('ECG al Cuadrado');

%Integracion
ecg_i = conv(ecg_s ,ones(1 ,round(0.150*fs))/round(0.150*fs));
ecg_i([4001: 4029],:)=[]
subplot (5,1,5);
plot (t, ecg_i);
title ('ECG Integrado');
xlabel ('tiempo');

%Conteo de los coplejos qrs integrados,

% qrs_amp_raw : amplitude of R waves amplitudes
% qrs_i_raw : index of R waves
% delay : number of samples which the signal is delayed due to the

[qrs_amp_raw,qrs_i_raw,delay]=pan_tompkins(ecg,fs,gr)

Se hizo uso de la función de pan_tompkings disponible en matlabworks para poder

calcular la amplitud y la posición de las señales integradas.