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 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 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 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 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 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 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
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(
"Bad argument. Specify 'e' for Einthoven or 'v' for the Chest strap."
)
exit(1)
r_peaks = detectors.swt_detector(ecg_channel_sitting)
sitting_rr_sd.append(hrv_class.RMSSD(r_peaks, True))
r_peaks = detectors.swt_detector(ecg_channel_maths)
maths_rr_sd.append(hrv_class.RMSSD(r_peaks, True))
sitting_error_rr = detectors.pan_tompkins_detector(ecg_channel_sitting)
sitting_error_rr_sd.append(hrv_class.RMSSD(sitting_error_rr, True))
maths_error_rr = detectors.pan_tompkins_detector(ecg_channel_maths)
maths_error_rr_sd.append(hrv_class.RMSSD(maths_error_rr, True))
maths_true_rr = maths_class.anno_cs
maths_true_sd.append(hrv_class.RMSSD(maths_true_rr, True))
sitting_true_rr = sitting_class.anno_cs
sitting_true_sd.append(hrv_class.RMSSD(sitting_true_rr, True))
subject = np.array(subject)
width = 0.4
fig, ax = plt.subplots()
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)))
def ecg_peaks(x, sfreq=1000, new_sfreq=1000, method='pan-tompkins',
find_local=True, win_size=100):
"""A simple wrapper for many popular R peaks detectors algorithms.
This function calls methods from the py-ecg-detectors [#]_ module.
Parameters
----------
x : list or 1d array-like
The oxi signal.
sfreq : int
The sampling frequency. Default is set to 75 Hz.
method : str
The method used. Can be one of the following: 'hamilton', 'christov',
'engelse-zeelenberg', 'pan-tompkins', 'wavelet-transform',
'moving-average'.
find_local : bool
If *True*, will use peaks indexs to search for local peaks given the
window size (win_size).
win_size : int
Size of the time window used by :py:func:`systole.utils.to_neighbour()`
Returns
-------
peaks : 1d array-like
Numpy array containing peaks index.
resampled_signal : 1d array-like
Signal resampled to the `new_sfreq` frequency.
Notes
-----
This function will call the py-ecg-detectors package to perform R wave
detection.
.. warning :: This function will resample the signal to 1000 Hz.
Examples
--------
>>> from systole import import_dataset
>>> from systole.detection import ecg_peaks
>>> signal_df = import_dataset()[:20*2000]
>>> signal, peaks = ecg_peaks(signal_df.ecg.to_numpy(), method='hamilton',
>>> sfreq=2000, find_local=True)
>>> print(f'{sum(peaks)} peaks detected.')
24 peaks detected.
References
----------
.. [#] Howell, L., Porr, B. Popular ECG R peak detectors written in
python. DOI: 10.5281/zenodo.3353396
"""
if isinstance(x, list):
x = np.asarray(x)
# Interpolate
f = interp1d(np.arange(0, len(x)/sfreq, 1/sfreq),
x,
fill_value="extrapolate")
time = np.arange(0, len(x)/sfreq, 1/new_sfreq)
x = f(time)
# Copy resampled signal for output
resampled_signal = np.copy(x)
detectors = Detectors(new_sfreq)
if method == 'hamilton':
peaks_idx = detectors.hamilton_detector(resampled_signal)
elif method == 'christov':
peaks_idx = detectors.christov_detector(resampled_signal)
elif method == 'engelse-zeelenberg':
peaks_idx = detectors.engzee_detector(resampled_signal)
elif method == 'pan-tompkins':
peaks_idx = detectors.pan_tompkins_detector(resampled_signal)
elif method == 'wavelet-transform':
peaks_idx = detectors.swt_detector(resampled_signal)
elif method == 'moving-average':
peaks_idx = detectors.two_average_detector(resampled_signal)
else:
raise ValueError(
'Invalid method provided, should be: hamilton,',
'christov, engelse-zeelenberg, pan-tompkins, wavelet-transform,',
'moving-average')
peaks = np.zeros(len(resampled_signal), dtype=bool)
peaks[peaks_idx] = True
if find_local is True:
peaks = to_neighbour(resampled_signal, peaks, size=win_size)
return resampled_signal, peaks
def run_algo(algorithm: str, sig: numpy.ndarray,
freq_sampling: int) -> List[int]:
"""
run a qrs detector on a signal
:param algorithm: name of the qrs detector to use
:type algorithm: str
:param sig: values of the sampled signal to study
:type sig: ndarray
:param freq_sampling: value of sampling frequency of the signal
:type freq_sampling: int
:return: localisations of qrs detections
:rtype: list(int)
"""
detectors = Detectors(freq_sampling)
if algorithm == 'Pan-Tompkins-ecg-detector':
qrs_detections = detectors.pan_tompkins_detector(sig)
elif algorithm == 'Hamilton-ecg-detector':
qrs_detections = detectors.hamilton_detector(sig)
elif algorithm == 'Christov-ecg-detector':
qrs_detections = detectors.christov_detector(sig)
elif algorithm == 'Engelse-Zeelenberg-ecg-detector':
qrs_detections = detectors.engzee_detector(sig)
elif algorithm == 'SWT-ecg-detector':
qrs_detections = detectors.swt_detector(sig)
elif algorithm == 'Matched-filter-ecg-detector' and freq_sampling == 360:
qrs_detections = detectors.matched_filter_detector(
sig, 'templates/template_360hz.csv')
elif algorithm == 'Matched-filter-ecg-detector' and freq_sampling == 250:
qrs_detections = detectors.matched_filter_detector(
sig, 'templates/template_250hz.csv')
elif algorithm == 'Two-average-ecg-detector':
qrs_detections = detectors.two_average_detector(sig)
elif algorithm == 'Hamilton-biosppy':
qrs_detections = bsp_ecg.ecg(signal=sig,
sampling_rate=freq_sampling,
show=False)[2]
elif algorithm == 'Christov-biosppy':
order = int(0.3 * freq_sampling)
filtered, _, _ = bsp_tools.filter_signal(signal=sig,
ftype='FIR',
band='bandpass',
order=order,
frequency=[3, 45],
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.christov_segmenter(signal=filtered,
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.correct_rpeaks(signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
tol=0.05)
_, qrs_detections = bsp_ecg.extract_heartbeats(
signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
before=0.2,
after=0.4)
elif algorithm == 'Engelse-Zeelenberg-biosppy':
order = int(0.3 * freq_sampling)
filtered, _, _ = bsp_tools.filter_signal(signal=sig,
ftype='FIR',
band='bandpass',
order=order,
frequency=[3, 45],
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.engzee_segmenter(signal=filtered,
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.correct_rpeaks(signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
tol=0.05)
_, qrs_detections = bsp_ecg.extract_heartbeats(
signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
before=0.2,
after=0.4)
elif algorithm == 'Gamboa-biosppy':
order = int(0.3 * freq_sampling)
filtered, _, _ = bsp_tools.filter_signal(signal=sig,
ftype='FIR',
band='bandpass',
order=order,
frequency=[3, 45],
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.gamboa_segmenter(signal=filtered,
sampling_rate=freq_sampling)
rpeaks, = bsp_ecg.correct_rpeaks(signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
tol=0.05)
_, qrs_detections = bsp_ecg.extract_heartbeats(
signal=filtered,
rpeaks=rpeaks,
sampling_rate=freq_sampling,
before=0.2,
after=0.4)
elif algorithm == 'mne-ecg':
qrs_detections = mne_ecg.qrs_detector(freq_sampling, sig)
elif algorithm == 'heartpy':
rol_mean = rolling_mean(sig, windowsize=0.75, sample_rate=100.0)
qrs_detections = hp_pkdetection.detect_peaks(
sig, rol_mean, ma_perc=20, sample_rate=100.0)['peaklist']
elif algorithm == 'gqrs-wfdb':
qrs_detections = processing.qrs.gqrs_detect(sig=sig, fs=freq_sampling)
elif algorithm == 'xqrs-wfdb':
qrs_detections = processing.xqrs_detect(sig=sig, fs=freq_sampling)
else:
raise ValueError(
f'Sorry... unknown algorithm. Please check the list {algorithms_list}'
)
cast_qrs_detections = [int(element) for element in qrs_detections]
return cast_qrs_detections
def ecg_detector(self, s, detector_type="pan_tompkins"):
"""
Expose
ECG peak detector from the github
https://github.com/berndporr/py-ecg-detectors
Parameters
----------
s :
Input signal
fs:
The signal frequency. Default is '256 Hz'
detector_type:
'hamilton': Open Source ECG Analysis Software Documentation,
E.P.Limited, 2002.
'christov':Real time electrocardiogram QRS detection using combined
adaptive threshold
'engzee': A single scan algorithm for QRS detection and
feature extraction
'swt': Real-time QRS detector using Stationary Wavelet Transform
for Automated ECG Analysis.
Uses the Pan and Tompkins thresolding.
'mva': Frequency Bands Effects on QRS Detection.
'mtemp':
'pan_tompkins': A Real-Time QRS Detection Algorithm
Default = 'pan_tompkins'
Returns
-------
type
an array of 1-D numpy array represent the peak list
"""
if self.wave_type == 'ppg':
warnings.warn("A ECG detectors is using on PPG waveform. "
"Output may produce incorrect result")
detector = Detectors(self.fs)
if detector_type == 'hamilton':
res = detector.hamilton_detector(s)
elif detector_type == 'christov':
res = detector.christov_detector(s)
elif detector_type == 'engzee':
res = detector.engzee_detector(s)
elif detector_type == 'swt':
res = detector.swt_detector(s)
elif detector_type == 'mva':
res = detector.two_average_detector(s)
elif detector_type == 'mtemp':
res = self.matched_filter_detector(s)
else:
res = detector.pan_tompkins_detector(s)
return np.array(res)