def pan_tompkins_single(fields, record, save_path, sig, save=True):
detectors = Detectors(fields['fs'])
r_peaks = detectors.pan_tompkins_detector(sig[:, 0])
if save:
save_prediction(r_peaks, record, save_path)
else:
return r_peaks
def stationary_wavelet_transform_single(fields, record, save_path, sig, save=True):
detectors = Detectors(fields['fs'])
r_peaks = detectors.swt_detector(sig[:, 0])
if save:
save_prediction(r_peaks, record, save_path)
else:
return r_peaks
def test_compute_qrs_frames_correlation(ecg_signal=ecg_signal,
qrs_frames_none=qrs_frames_none,
fs=fs):
detectors = Detectors(fs)
qrs_frames_swt = detectors.swt_detector(ecg_signal)
qrs_frames_hamilton = bsp_ecg.hamilton_segmenter(
signal=np.array(ecg_signal), sampling_rate=fs)[0]
correlation_coefs = compute_qrs_frames_correlation(
qrs_frames_1=qrs_frames_swt,
qrs_frames_2=qrs_frames_hamilton,
sampling_frequency=fs)
assert isinstance(correlation_coefs, float)
# test for qrs without length
correlation_coefs_none_1 = compute_qrs_frames_correlation(
qrs_frames_1=qrs_frames_none,
qrs_frames_2=qrs_frames_hamilton,
sampling_frequency=fs)
assert correlation_coefs_none_1 == 0
correlation_coefs_none_2 = compute_qrs_frames_correlation(
qrs_frames_1=qrs_frames_swt,
qrs_frames_2=qrs_frames_none,
sampling_frequency=fs)
assert correlation_coefs_none_2 == 0
def test_addRepetitionDelay(self):
ecg, fecg = self.dataUtils.readData(0)
detectors = Detectors(200)
# fecgDelayed = self.dataUtils.createDelayRepetition(fecg, 4, 5)
# self.assertIsNotNone(fecgDelayed)
r_peaks = detectors.hamilton_detector(ecg)
pass
def two_moving_average_single(fields, record, save_path, sig, save=True):
detectors = Detectors(fields['fs'])
r_peaks = detectors.two_average_detector(sig[:, 0])
if save:
save_prediction(r_peaks, record, save_path)
else:
return r_peaks
def qsqi(ecg_signal: list, sampling_frequency: int) -> float:
"""Matching Degree of R Peak Detection
Two R wave detection algorithms are compared with their respective number
of R waves detected.
* Hamilton
* SWT (Stationary Wavelet Transform)
Parameters
----------
ecg_signal : list
Input ECG signal
sampling_frequency : list
Input ecg sampling frequency
Returns
-------
q_sqi_score : float
"""
detectors = Detectors(sampling_frequency)
qrs_frames_swt = detectors.swt_detector(ecg_signal)
qrs_frames_hamilton = bsp_ecg.hamilton_segmenter(
signal=np.array(ecg_signal), sampling_rate=sampling_frequency)[0]
q_sqi_score = compute_qrs_frames_correlation(qrs_frames_hamilton,
qrs_frames_swt,
sampling_frequency)
return q_sqi_score
def stopmeasuring():
global sp
print('killing process with id: ', sp)
os.system("taskkill /f /t /pid " + str(sp))
print("subprocess stopped")
df = pd.read_csv('data.csv', index_col=None, header=0)
ecg_signal = df['ECG'] * 1000
sr = 60
time = np.linspace(0, len(ecg_signal) / sr, len(ecg_signal))
detectors = Detectors(sr)
r_peaks = detectors.pan_tompkins_detector(ecg_signal)
peaks = np.array(time)[r_peaks]
RRinterval = np.diff(peaks)
median = np.median(RRinterval)
RRinterval = np.append(RRinterval, median)
df = df.iloc[r_peaks]
df["RRinterval"] = RRinterval
df["RRinterval"] = np.where(df["RRinterval"] < 0.5, median,
df["RRinterval"])
df["RRinterval"] = np.where(df["RRinterval"] > 1.5, median,
df["RRinterval"])
df["RRinterval"] = signal.medfilt(df["RRinterval"], 5)
rri = df['RRinterval']
diff_rri = np.diff(rri)
NNRR = round(len(np.diff(rri)) / len(rri), 6)
RMSSD = np.sqrt(np.mean(diff_rri**2))
SDNN = np.nanstd(rri, ddof=1)
AVNN = np.nanmean(rri)
nn50 = np.sum(np.abs(diff_rri) > 0.05)
pNN50 = nn50 / len(rri)
df['NNRR'] = NNRR
df['RMSSD'] = RMSSD
df['SDNN'] = SDNN
df['AVNN'] = AVNN
df['pNN50'] = pNN50
print(df.describe())
df = df.replace([np.inf, -np.inf], np.nan)
df['HR'].fillna((df['HR'].mean()), inplace=True)
df['HR'] = signal.medfilt(df['HR'], 5)
df['RESP'].fillna((df['RESP'].mean()), inplace=True)
df['RESP'] = signal.medfilt(df['RESP'], 5)
df['EMG'].fillna((df['EMG'].mean()), inplace=True)
df['EMG'] = signal.medfilt(df['EMG'], 5)
df['ECG'].fillna((df['ECG'].mean()), inplace=True)
df['ECG'] = signal.medfilt(df['ECG'], 5)
df = df.fillna(df.mean())
df.to_csv('test_data2.csv', index=False)
df = df.drop(['time'], axis=1)
predictions = ExtraTreesClassifier.predict(df)
print('predictions: ', predictions)
c = (predictions == 0).sum()
c1 = (predictions == 1).sum()
if c < c1:
class_ = 'stressed'
return render_template('stressed.html', pred=class_)
else:
class_ = 'not stressed'
return render_template('notstressed.html', pred=class_)
print(class_)
def detect_r_peaks(SampleRate, data):
"""
R peaks detection and RR intervals calculation
"""
detectors = Detectors(SampleRate) # use library for peak detection to get array of r peak positions
r_peaks = detectors.engzee_detector(data)
r_peaks = np.array(r_peaks) # convert list to array
return r_peaks
def detect_qrs_swt(ecg_data, fs):
qrs_frames = []
try:
detectors = Detectors(fs) # Explain why
qrs_frames = detectors.swt_detector(ecg_data)
except Exception:
# raise ValueError("swt")
print("Exception in detect_qrs_swt")
return qrs_frames
def __init__(self, path):
self.path = path
self.file = path.split(".")[0][-3:]
self.good = {
'N': 1,
'L': 1,
'R': 1,
'B': 1,
'A': 2,
'a': 2,
'J': 2,
'S': 2,
'V': 3,
'r': 3,
'F': 4,
'e': 2,
'j': 2,
'n': 2,
'E': 3,
'/': 5,
'f': 5,
'Q': 5,
'?': 5
}
self.ann_arr = [
"(AB", "(AFIB", "(AFL", "(B", "(BII", "(IVR", "(N", "(NOD", "(P",
"(PREX", "(SBR", "(SVTA", "(T", "(VFL", "(VT"
]
self.quality = ["TS", "PSE", "MISSB", "U", "qq", 0]
self.detectors = Detectors(360)
self.record1 = None
self.record2 = None
self.record_detail = None
self.n_ann = None # number of annotations
self.inds = None # indexes of annotation according to 650 000 array values
self.arrhyt = None # arrythmias names and 0 if no, according to self.inds
self.beat = None # beat names, according to self.inds
# read data for the sample
self.read_record()
self.read_annot()
self.good_int = [
i for i in range(len(self.ann_arr))
] #arrhythmias indexes coresponding value sin self.ann_arr
self.beats_full = None # 0 for no annotation from 1- 5 name of beat
self.arrhyt_full = None # -1 for no annotation 0-14 name of arrhythmia
self.clean_ann_beat()
self.convert_arr_ann()
self.r_peaks = None
self.get_r_peaks()
def engelze_zeelenberg_single(fields, record, save_path, sig, save=True):
detectors = Detectors(fields['fs'])
try:
r_peaks = detectors.engzee_detector(sig[:, 0])
except Exception:
r_peaks = [0]
if save:
save_prediction(r_peaks, record, save_path)
else:
return r_peaks
def pan_tompkins_detector(signal):
from ecgdetectors import Detectors
detectors = Detectors(500)
annotation = []
for i in range(0, 8):
annotation.append(detectors.pan_tompkins_detector(signal[i][:]))
# annotation.append(detectors.pan_tompkins_detector(signal[1][:]))
return annotation
def heart_rate_variability(sample, lead, rpeak_method = 'string'):
curdir = 'DATA\TrainData_FeatureExtraction'
[all_data, header_data, BAD_LABELS] = data_read.data_files_load(curdir)
data = all_data[sample][lead]
"""INITIALIZE DETECTOR CLASS WITH THE SAMPLING RATE:"""
detectors = Detectors(500)
"""FIND RPEAK USING ONE OF THE METHODS BELOW--------------------"""
if rpeak_method == 'hamilton' or rpeak_method == 'string':
#Hamilton.
r_peaks = detectors.hamilton_detector(data)
elif rpeak_method == 'christov':
#Christov
r_peaks = detectors.christov_detector(data)
elif rpeak_method == 'engelse':
#Engelse and Zeelenberg
r_peaks = detectors.engzee_detector(data)
elif rpeak_method == 'pan':
#Pan and Tompkins
r_peaks = detectors.pan_tompkins_detector(data)
elif rpeak_method == 'stationary_wavelet':
#Stationary Wavelet Transform
r_peaks = detectors.swt_detector(data)
elif rpeak_method == 'two_moving_average':
#Two Moving Average
r_peaks = detectors.two_average_detector(data)
#elif rpeak_method == 'matched_filter':
#Matched Filter
#go to pyhrv documentation to find the template file
#r_peaks = detectors.matched_filter_detector(data,template_file)
"""COMPUTE NNI SERIES-------------------------------------------"""
nn = nn_intervals(r_peaks) #nni seems to be off by a factor of 3
print("\n\n", nn, "\n\n")
"""PLOT ECG/TACHOGRAM-------------------------------------------"""
#plot_ecg(data, sampling_rate = 500)
#tachogram(nn, sampling_rate = 500)
"""COMPUTE HRV--------------------------------------------------"""
results = hrv(nn, None, None, 500)
"""COMPUTE HR PARAMETERS--(SOMETHING IS WRONG HERE BPM TOO HIGH)"""
hr = heart_rate(nn)
"""COMPUTE FREQUENCY ANALYSIS-----------------------------------"""
freq_results = results['fft_bands']
return results, hr, freq_results
def predict_labels(ecg_leads,fs,ecg_names,use_pretrained=False):
'''
Parameters
----------
model_name : str
Dateiname des Models. In Code-Pfad
ecg_leads : list of numpy-Arrays
EKG-Signale.
fs : float
Sampling-Frequenz der Signale.
ecg_names : list of str
eindeutige Bezeichnung für jedes EKG-Signal.
Returns
-------
predictions : list of tuples
ecg_name und eure Diagnose
'''
#------------------------------------------------------------------------------
# Euer Code ab hier
# From here add some our code
model_name = "model.npy"
if use_pretrained:
model_name = "model_pretrained.npy"
with open(model_name, 'rb') as f:
th_opt = np.load(f) # Lade simples Model (1 Parameter)
detectors = Detectors(fs) # Initialisierung des QRS-Detektors
predictions = list()
for idx,ecg_lead in enumerate(ecg_leads):
r_peaks = detectors.hamilton_detector(ecg_lead) # Detektion der QRS-Komplexe
sdnn = np.std(np.diff(r_peaks)/fs*1000)
if sdnn < th_opt:
predictions.append((ecg_names[idx], 'N'))
else:
predictions.append((ecg_names[idx], 'A'))
if ((idx+1) % 100)==0:
print(str(idx+1) + "\t Dateien wurden verarbeitet.")
#------------------------------------------------------------------------------
return predictions # Liste von Tupels im Format (ecg_name,label) - Muss unverändert bleiben!
def extract_features(data, sampling_rate):
detector = Detectors(sampling_rate)
hrv_class = HRV(sampling_rate)
# Borrar si todo va bien
# np.array_split(data, sampling_rate)
# PROCESAR POR TROZOS
# FOR splitted data
# Unir horizontalmente ecg y eda
# unir verticalmente cada iteracion
splitted = split_in_seconds(data, sampling_rate, 30)
seccion = None
names = None
for idx, m in enumerate(splitted):
print(f'Procesando split {idx} con longitud {len(m)}')
try:
ecg, names_ecg = ecg_processing(m[:, 1], detector, hrv_class)
eda, names_eda = eda_processing(m[:, 0])
full_iteration = np.hstack((eda, ecg))
if seccion is None:
seccion = np.empty((0, len(full_iteration)))
names = names_eda + names_ecg + ["stress_lvl"]
seccion = np.vstack((seccion, full_iteration))
except Exception:
print("Error en un dato. Continuando...")
continue
return seccion, names
def test_ecg_detectors_package(self):
for i in range(100, 300):
try:
record_name = self.mitdb + str(i)
sig, fields = wfdb.rdsamp(record_name, channels=[0])
detectors = Detectors(fields['fs'])
r_peaks = detectors.pan_tompkins_detector(sig[:, 0])
samples = np.array(r_peaks)
wfdb.wrann(str(i),
'atr',
sample=samples,
write_dir="data/ann",
symbol=(['N'] * len(r_peaks)))
print(i)
except Exception as e:
print(i, e)
def find_peaks(ecg_df):
unfiltered_ecg = ecg_df['ecg'].values
fs = 500 # sampling freq. in Hz
detectors = Detectors(fs)
# r_peaks = detectors.two_average_detector(unfiltered_ecg)
# r_peaks = detectors.matched_filter_detector(unfiltered_ecg,"templates/template_250hz.csv")
# r_peaks = detectors.swt_detector(unfiltered_ecg)
r_peaks = detectors.engzee_detector(unfiltered_ecg)
# r_peaks = detectors.christov_detector(unfiltered_ecg)
# r_peaks = detectors.hamilton_detector(unfiltered_ecg)
# r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)
r_peaks = ecg_df['timestamp'][r_peaks].values
return r_peaks
def ECG_segment(dataset, channel_num=0):
segments_per_ECG = []
all_preprocessed_datas = []
all_r_peaks = []
for rec in dataset:
ecg_all_channel = rec[0]
ecg_channel_1 = ecg_all_channel[:, channel_num]
#Done by gautham
pre_precocessed_data = overall_preprocessing(ecg_channel_1)
pre_precocessed_data = pre_precocessed_data[:-9]
detectors = Detectors(fs)
#Peak Detection
r_peaks = detectors.pan_tompkins_detector(pre_precocessed_data)
all_r_peaks.append(r_peaks)
#Peak Segmentation
all_segments = []
count = 0
for i in range(len(r_peaks)):
data_segment = np.zeros((1, 500), dtype=float)
data_segment = data_segment.ravel()
if ((r_peaks[i] - 250) >= 0
and (r_peaks[i] + 250) < len(pre_precocessed_data)):
data_segment = pre_precocessed_data[r_peaks[i] -
250:r_peaks[i] + 250]
count = count + 1
elif ((r_peaks[i] - 250) < 0):
nZeros = 250 - r_peaks[i]
data_segment[nZeros:500] = pre_precocessed_data[0:r_peaks[i] +
250]
count = count + 1
elif (r_peaks[i] + 250 > len(pre_precocessed_data)):
nZeros = r_peaks[i] + 250 - len(pre_precocessed_data)
data_segment[0:500 - nZeros] = pre_precocessed_data[
r_peaks[i] - 250:len(pre_precocessed_data)]
count = count + 1
all_segments.append(data_segment)
all_preprocessed_datas.append(pre_precocessed_data)
segments_per_ECG.append(all_segments)
return segments_per_ECG, all_preprocessed_datas, all_r_peaks
def run_MIT_tests():
# MIT-BIH database testing
mit_test = MITDB_test()
mit_detectors = Detectors(360)
# test single detector
matched_filter_mit = mit_test.single_classifier_test(mit_detectors.matched_filter_detector, tolerance=0)
np.savetxt('matched_filter_mit.csv', matched_filter_mit, fmt='%i', delimiter=',')
# test all detectors on MITDB, will save results to csv, will take some time
mit_test.classifer_test_all()
def det_from_name(detector_name, fs):
detectors = Detectors(fs)
detectors.engzee_fake_delay = 10
if detector_name == 'two_average':
return detectors.two_average_detector
elif detector_name == 'matched_filter':
return detectors.matched_filter_detector
elif detector_name == 'swt':
return detectors.swt_detector
elif detector_name == 'engzee':
return detectors.engzee_detector
elif detector_name == 'christov':
return detectors.christov_detector
elif detector_name == 'hamilton':
return detectors.hamilton_detector
elif detector_name == 'pan_tompkins':
return detectors.pan_tompkins_detector
else:
raise RuntimeError('invalid detector name!')
def num_beats(voltage, time):
"""Counts number of heartbeats in ECG strip data
The peaks of an ECG indicate a heart beat, with each
peak indicative of a QRS wave. By counting these beats,
the heart rate can be determined, which can further be
used to diagnose deeper conditions.
Args:
voltage (list): voltage data of the ECG strip
time (list): time data of the ECG strip
Returns:
int: number of peaks/beats in the ECG strip
list: indices of ECG peaks identified
"""
logging.info("Calculating number of beats in ECG trace")
fs = 1 / (time[1] - time[0])
detectors = Detectors(fs)
unfiltered_ecg = voltage
r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)
num_peaks = len(r_peaks)
return num_peaks, r_peaks
total_subjects = 25
subject = []
if len(sys.argv) < 2:
print("Specify 'e' for Einthoven or 'v' for chest strap ECG.")
exit(1)
for i in range(total_subjects):
#for i in range(2):
print(i)
sitting_class = Ecg(data_path, i, 'sitting')
sitting_class.filter_data()
maths_class = Ecg(data_path, i, 'maths')
maths_class.filter_data()
detectors = Detectors(sitting_class.fs)
if sitting_class.anno_cs_exists and maths_class.anno_cs_exists and (i !=
11):
subject.append(i)
hrv_class = HRV(sitting_class.fs)
if "e" in sys.argv[1]:
ecg_channel_sitting = sitting_class.einthoven_II
ecg_channel_maths = maths_class.einthoven_II
elif "v" in sys.argv[1]:
ecg_channel_sitting = sitting_class.cs_V2_V1
ecg_channel_maths = maths_class.cs_V2_V1
else:
print(
interval_differences_for_jitter.append(difference)
missed_beats = unused_anno #for clarity
extra_beats = extra_det_posn #for clarity
return interval_differences_for_jitter, missed_beats, extra_beats
#%%
"""
***************************
START OF MAIN CODE
***************************
"""
fs = 250 #sampling rate
detectors = Detectors(fs)# Initialise detectors for 250Hz sample rate (GUDB)
current_dir = pathlib.Path(__file__).resolve()
#%% Initialise parameters for analysis
save_global_results = True # when 'True' saves global jitter, missed, extra values as csv and prints
trim=True # CHANGE TO FALSE IF YOU DONT WANT TO TRIM
a = 10 # number of annotated beats to trim from start
b = -5 # number of annotated beats to trim from end
# * Values chosen by observation of detector settling intervals required *
#initialise for plots (*if used*)
plt.rc('xtick',labelsize=10)
plt.rc('ytick',labelsize=10)
nan_count += 1
data.append([user_id, action, ecg1, ecg2, radari, radarq, bp])
dataframe = pd.DataFrame(
data, columns=['user', 'action', 'ecg1', 'ecg2', 'radari', 'radarq', 'bp'])
#dataframe.to_pickle('/scratch/lnw8px/ECG_radar/data.pkl')
print('how many values with nan are present now ? - ' + str(nan_count))
#detecting the R peaks from the ECG signal to detect heart rate
#use a library called ecgdetectors from Glasgov university
from ecgdetectors import Detectors
path = '/scratch/lnw8px/ECG_radar/clinical/GDN0001/GDN0001_1_Resting.mat'
x = loadmat(path)
fs_ecg = x['fs_ecg'][0, 0]
detectors = Detectors(fs_ecg)
ecg2 = x['tfm_ecg2'].squeeze()
#select a part of the signal for easy visualization
sig = ecg2[8000:16000]
#detect R peaks with engzee_detector
#see https://github.com/berndporr/py-ecg-detectors for details
r_peaks = detectors.engzee_detector(sig)
plt.figure()
plt.plot(sig)
plt.plot(r_peaks, sig[r_peaks], 'ro')
plt.title('Detected R-peaks')
#get the time difference between r_peaks to calculate the time between two heart beats
sig = ecg2
r_peaks = detectors.engzee_detector(sig)
def prep_data(self):
"""Function that:
-Initializes ecgdetector class instance
-Runs stationary wavelet transform peak detection
-Implements 0.1-10Hz bandpass filter
-DB3 wavelet transformation
-Pan-Tompkins peak detection thresholding
-Calculates RR intervals
-Removes first peak if it is within median RR interval / 2 from start of window
-Calculates average HR in the window
-Determines if there are enough beats in the window to indicate a possible valid period
"""
# Initializes Detectors class instance with sample rate
detectors = Detectors(self.fs)
# Runs peak detection on raw data ----------------------------------------------------------------------------
# Uses ecgdetectors package -> stationary wavelet transformation + Pan-Tompkins peak detection algorithm
self.r_peaks = list(detectors.swt_detector(unfiltered_ecg=self.filt_data))
# List of peak indexes relative to start of data file (i = 0)
self.output_r_peaks = [i + self.start_index for i in self.r_peaks]
# Checks to see if there are enough potential peaks to correspond to correct HR range ------------------------
# Requires number of beats in window that corresponds to ~40 bpm to continue
# Prevents the math in the self.hr calculation from returning "valid" numbers with too few beats
# i.e. 3 beats in 3 seconds (HR = 60bpm) but nothing detected for rest of epoch
if len(self.r_peaks) >= np.floor(40/60*self.epoch_len):
self.enough_beats = True
n_beats = len(self.r_peaks) # number of beats in window
delta_t = (self.r_peaks[-1] - self.r_peaks[0]) / self.fs # time between first and last beat, seconds
self.hr = 60 * (n_beats-1) / delta_t # average HR, bpm
# Stops function if not enough peaks found to be a potential valid period
# Threshold corresponds to number of beats in the window for a HR of 40 bpm
if len(self.r_peaks) < np.floor(40/60*self.epoch_len):
self.enough_beats = False
self.valid_period = False
return
# Calculates RR intervals in seconds -------------------------------------------------------------------------
for peak1, peak2 in zip(self.r_peaks[:], self.r_peaks[1:]):
rr_interval = (peak2 - peak1) / self.fs
self.delta_rr.append(rr_interval)
# Approach 1: median RR characteristics ----------------------------------------------------------------------
# Calculates median RR-interval in seconds
median_rr = np.median(self.delta_rr)
# Converts median_rr to samples
self.median_rr = int(median_rr * self.fs)
# Removes any peak too close to start/end of data section: affects windowing later on ------------------------
# Peak removed if within median_rr/2 samples of start of window
# Peak removed if within median_rr/2 samples of end of window
for i, peak in enumerate(self.r_peaks):
if peak < (self.median_rr/2 + 1) or (self.epoch_len*self.fs - peak) < (self.median_rr/2 + 1):
self.removed_peak.append(self.r_peaks.pop(i))
self.removal_indexes.append(i)
# Removes RR intervals corresponding to
if len(self.removal_indexes) != 0:
self.delta_rr = [self.delta_rr[i] for i in range(len(self.r_peaks)) if i not in self.removal_indexes]
# Calculates range of ECG voltage ----------------------------------------------------------------------------
self.volt_range = max(self.raw_data) - min(self.raw_data)
def run_GUDB_tests(leads):
# GUDB database testing
gu_test = GUDB_test()
gu_detectors = Detectors(250)
gu_test.classifer_test_all(tolerance=0, config=leads)
import numpy as np
import matplotlib.pyplot as plt
import pathlib
from ecgdetectors import Detectors
current_dir = pathlib.Path(__file__).resolve()
example_dir = current_dir.parent / 'example_data' / 'ECG.tsv'
unfiltered_ecg_dat = np.loadtxt(example_dir)
unfiltered_ecg = unfiltered_ecg_dat[:, 0]
fs = 250
detectors = Detectors(fs)
#r_peaks = detectors.two_average_detector(unfiltered_ecg)
#r_peaks = detectors.matched_filter_detector(unfiltered_ecg)
r_peaks = detectors.swt_detector(unfiltered_ecg)
#r_peaks = detectors.engzee_detector(unfiltered_ecg)
#r_peaks = detectors.christov_detector(unfiltered_ecg)
#r_peaks = detectors.hamilton_detector(unfiltered_ecg)
#r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)
plt.figure()
plt.plot(unfiltered_ecg)
plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')
plt.title('Detected R-peaks')
plt.show()
import numpy as np
from tester_MITDB import MITDB_test
from tester_GUDB import GUDB_test
from ecgdetectors import Detectors
# MIT-BIH database testing
mit_test = MITDB_test(r'C:\Users\Luis\Documents\MITDB')
mit_detectors = Detectors(360)
# test single detector
matched_filter_mit = mit_test.single_classifier_test(
mit_detectors.matched_filter_detector, tolerance=0, print_results=True)
np.savetxt('matched_filter_mit.csv',
matched_filter_mit,
fmt='%i',
delimiter=',')
# test all detectors on MITDB, will save results to csv, will take some time
mit_results = mit_test.classifer_test_all()
# McNemars stats test
Z_value_mit = mit_test.mcnemars_test(mit_detectors.swt_detector,
mit_detectors.two_average_detector,
print_results=True)
# GUDB database testing
gu_test = GUDB_test()
gu_detectors = Detectors(250)
swt_gudb = gu_test.single_classifier_test(gu_detectors.swt_detector,
tolerance=0,
import pandas as pd
import neurokit2 as nk
from sklearn.datasets import make_hastie_10_2
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score
from wettbewerb import load_references
from imblearn.over_sampling import SMOTE
import warnings
warnings.filterwarnings("ignore")
ecg_leads, ecg_labels, fs, ecg_names = load_references(
) # Importiere EKG-Dateien, zugehörige Diagnose, Sampling-Frequenz (Hz) und Name # Sampling-Frequenz 300 Hz
features = np.array([])
detectors = Detectors(fs) # Initialisierung des QRS-Detektors
labels = np.array([])
for idx, ecg_lead in enumerate(ecg_leads):
if (ecg_labels[idx] == "N") or (ecg_labels[idx] == "A"):
peaks, info = nk.ecg_peaks(ecg_lead, sampling_rate=fs)
peaks = peaks.astype('float64')
hrv = nk.hrv_time(peaks, sampling_rate=fs)
hrv = hrv.astype('float64')
features = np.append(features, [
hrv['HRV_CVNN'], hrv['HRV_CVSD'], hrv['HRV_HTI'], hrv['HRV_IQRNN'],
hrv['HRV_MCVNN'], hrv['HRV_MadNN'], hrv['HRV_MeanNN'],
hrv['HRV_MedianNN'], hrv['HRV_RMSSD'], hrv['HRV_SDNN'],
hrv['HRV_SDSD'], hrv['HRV_TINN'], hrv['HRV_pNN20'],
hrv['HRV_pNN50']
])
import wfdb
from ecgdetectors import Detectors
import numpy as np
DATA_PATH = "/data/"
SAVE_PATH = "/pred/"
with open(DATA_PATH + "RECORDS", 'r') as f:
records = f.readlines()
records = list(map(lambda r: r.strip("\n"), records))
for record in records:
sig, fields = wfdb.rdsamp(DATA_PATH + record, channels=[0])
detectors = Detectors(fields['fs'])
r_peaks = detectors.pan_tompkins_detector(sig[:, 0])
if len(r_peaks) > 0:
samples = np.array(r_peaks)
wfdb.wrann(record,
'atr',
sample=samples,
write_dir=SAVE_PATH,
symbol=(['N'] * len(r_peaks)))
