You are on page 1of 13

Analiza semnalului ECG

pornind de la metoda
Pan-Tompkins














Algoritm de detectare a QRS-ului dintr-un semnal ECG


Modelul algoritmului prezent a pornit din algoritmul Pan-
Tompkins.
Se pune problema determinării bătăilor de inimă dintr-o
electrocardiogramă. Ţinta lucrării este afişarea acestor vârfuri şi
eliminarea zgomotului.
Modelul Pan-Tompkins realizează detecţia QRS-ului în timp
real pe baza analizei pantelor, amplitudinilor şi lăţimii vârfurilor
QRS. Algoritmul include o serie de filtre şi metode de prelucrare:
filtru trece jos, filtre trece sus, derivare, ridicare la pătrat, integrare,
adaptarea pragului de trecere şi metode de căutare. În figura
următoare este prezentată schematic acest algoritm.






Filtrul trece jos

Filtrul trece jos recursiv folosit de algoritmul Pan-Tompkins
are coeficienţi întregi pentru a reduce complexitatea calculelor şi
are funcţia de transfer definită astfel:

( )
2 1
2 6
) 1 (
) 1 (
32
1




=
z
z
z H
.

Ieşirea y(n) se raportează la intrarea x(n) după relaţia:

)] 12 ( ) 6 ( 2 ) ( [
32
1
) 2 ( ) 1 ( 2 ) ( − + − − + − − − = n x n x n x n y n y n y

Cu o rată de eşantionare de 200 Hz, filtrul are frecvenţa de
tăiere jos de 11 Hz şi introduce o întârziere de 5 eşantioane sau de
FILTRU TRECE
BANDĂ
DIFERENŢIATOR
RIDICARE LA
PĂTRAT
INTEGRARE
25 ms. Filtrul oferă o atenuare mai mare de 35 dB la 60 Hz şi
elimină interferenţa reţelei.

Filtrul trece sus

Filtrul este implementat ca un filtru trece tot şi un filtru trece
jos. Funcţia filtrului trece jos are funcţia de transfer:

1
32
1
1
) (




=
z
z
z H
lp


relaţia intrare-ieşire este

). 32 ( ) ( ) 1 ( ) ( − − + − = n x n x n y n y


Funcţia de transfer a filtrului trece sus este:

). (
32
1
) (
16
z H z z H
lp hp
− =



Analog, ieşirea p(n) a filtrului trece sus este dată de relaţia
diferenţa:

)], 32 ( ) ( ) 1 ( [
32
1
) 16 ( ) ( − − + − − − = n x n x n y n x n p


filtrul are frecvenţa de tăiere de 5 Hz şi introduce întârzieri de 80
ms.




Derivarea

)] 4 ( 2 ) 3 ( ) 1 ( ) ( 2 [
8
1
) ( − − − − − + = n x n x n x n x n y

şi aproximează operatorul de derivare în raport cu timpul până la
frecvenţa de 30 Hz. Procedeul de derivare are rolul de a suprima
componentele de frecvenţă joasă a semnalelor de tip P şi T şi
amplifică componentele de frecvenţă înaltă care apar în pantele
QRS.

Ridicarea la pătrat

Are rolul de a elimina părţile negative ale semnalului şi de a
accentua diferenţele mari de amplitudine care apar datorită QRS şi
de a elimina amplitudinile mici ale date de P şi T.

Integrarea

În urma derivării semnalul rezultat are multe vârfuri. Aceste
vârfuri sunt netezite cu o fereastră de integrare alunecătoare:

)]. ( ... )) 2 ( ( )) 1 ( ( [
1
) ( n x N n x N n x
N
n y + + − − + − − =


Alegerea lăţimii N a ferestrei s-a făcut pe baza următoarelor
criterii: o valoare prea mare va determina amestecarea semnalelor
QRS şi T, iar o valoare prea mică duce la apariţia mai multor
vârfuri. Astfel, pentru o eşantionare de 200 Hz cea mai potrivită
lungime de fereastră este cea cu lungimea de 30.
Implementare

Programul care implementeaza in Matlab detectia QRS din
semnalul ECG este urmatorul:


% MATLAB PROGRAM PT.m
% Use this program to read the files ECG3.dat, ECG4.dat, ECG5.dat, and
ECG6.dat (one at a time)
% Run the program by entering at the MATLAB command line
% PT
% and provide the name of the input file to be read in response to the prompt

clear all % clears all active variable
close all
warning off

%% Loading the ECG file %%
fnam =input('Enter the ECG file name :','s');
fid =fopen(fnam);
ecg =fscanf(fid,'%f ');
fs =200; %sampling rate
sze =length(ecg);
necg =ecg/max(ecg); % normalize the maximum value to unity
time =[1 : sze]/fs;
figure(1);
subplot(3,1,1);
plot(time,necg);
axis tight;
ylabel('ECG');

K=length(ecg);
%LPF
y1=zeros(1,K);
for i=13:K
y1(i)=2*y1(i-1)-y1(i-2)+1/32*(ecg(i)-2*ecg(i-6)+ecg(i-12));
end

%HPF
y21=zeros(1,K);
for i=33:K
y21(i)=y21(i-1)+y1(i)-y1(i-32);
end
y2=zeros(1,K);
for i=33:K
y2(i)=y1(i-16)-1/32*(y21(i-1)+y1(i)-y1(i-32));
end
subplot(3,1,2);
plot(time,y2);
ylabel('BandPassFiltered');
axis tight;

%Derivare
y3=zeros(1,K);
for i=5:K
y3(i)=1/8*(2*y2(i)+y2(i-1)-y2(i-3)-2*y2(i-4));
end
subplot(3,1,3);
plot(time,y3);
ylabel('Derived');
axis tight;
xlabel('Time in seconds');

%Squared
y4=y3.*y3;
figure(2);
subplot(3,1,1);
plot(time,y4);
ylabel('Squared');
axis tight;

%Integrated
N=30;
y5=zeros(1,N+1);
for i=N+1:K
dif=0;
for j=1:N
dif=dif+y4(i-(N-j));
end
y5(i)=1/N*dif;
end
nyf=y5/max(y5);
subplot(3,1,2);
plot(time,nyf);
ylabel('Integrated');
axis tight;

%peak detection
pk=zeros(1,K);
speak=zeros(1,K);
npeak=zeros(1,K);
peak=zeros(1,K);
momente=zeros(1,8);
for i=2:K-1
if((nyf(i)-nyf(i-1))/(nyf(i+1)-nyf(i))<0)
pk(i)=1;
end
end
peak=zeros(1,K);

%vector cu varfuri
for i=21:K-20
if pk(i)==1
maxv=max(nyf(i-20:i+20));
for j=i-20:i+20
if nyf(j)==maxv
peak(j)=nyf(j);
else
peak(j)=0;
end
end
end
end

%vector cu varfuri
for i=11:K-10
if peak(i)>0
maxv=max(peak(i-10:i+10));
for j=i-10:i+10
if peak(j)==maxv
peak(j)=nyf(j);
else
peak(j)=0;
end
end
end
end

for i=1:K
if pk(i)==1
if peak(i)>((max(peak)+min(peak))/2)
speak(i)=peak(i);
else
npeak(i)=nyf(i);
end
end
end

subplot(3,1,3);
stem(time,peak);
axis tight;
ylabel('Peak');
xlabel('Time in seconds');

figure(3);
subplot(3,1,1);
plot(time,nyf);
ylabel('Integrated');
axis tight;
subplot(3,1,2);
stem(time,speak);
ylabel('SignalPeak');
axis tight;
subplot(3,1,3);
stem(time,npeak);
ylabel('NoisePeak');
axis tight;
xlabel('Time in seconds');

figure(4);
subplot(3,1,1);
plot(time,necg);
axis tight;
ylabel('ECG');
subplot(3,1,2);
plot(time,nyf);
ylabel('Integrated');
axis tight;
subplot(3,1,3);
stem(time,speak);
ylabel('SignalPeak');
axis tight;
xlabel('Time in seconds');

%Rasp=input('Rulare Incheiata !');


Dupa rulare programul afiseaza urmatoarele figuri:

Pentru semnalul ecg2x60.dat avem urmatoarele rezultate:








Pentru semnalul ecg3.dat:




Pentru semnalul ecg4.dat :

Concluzii

În implementare nu s-a mai folosit filtrarea adaptivă, însă s-a
folosit o metodă de determinare a vârfurilor semnalului după
integrare. Metoda este folosită în cascadă prima dată pentru a
detecta toate vârfurile existente, iar a doua oară pentru a obţine
maximele care coincid cu vârfurile QRS.
Algoritmul funcţionează bine doar pentru semnale ECG care
nu au zgomote prea mari. Acurateţea algoritmului este bună pentru
un semnal care redă funcţionarea inimii unui om sănătos. Dacă
bătăile inimii sunt prea dese, algoritmul are o problemă de alegere
a vârfurilor. De aceea trebuie făcută o “filtrare” mai selectivă a
virfurilor, de asemenea trebuie revizuit pragul din decizia asupra
virfurilor.