def get_heartrate_and_breathing(self, data):
framerate = self.framerate
if self.resample != -1:
data = resample(data,
(len(data) // self.framerate) * self.resample)
framerate = self.resample
if self.filter:
data = hp.filter_signal(data, [0.7, 3.5],
sample_rate=framerate,
order=3,
filtertype='bandpass')
data = hp.scale_data(data)
wd, m = hp.process(data, framerate, high_precision=True, clean_rr=True)
self.m = m
self.wd = wd
hr = m["bpm"]
rr = m["breathingrate"]
if self.show:
hp.plotter(wd, m)
if self.save_path != '':
save_plot(data, x_label="Time", y_label="BVP Signal")
return hr, rr * 60
def process_ecg(self):
"""Runs heartpy.process on up-sampled data and creates a timestamp for each detected beat"""
print("\n" + "Detecting peaks using the HeartPy algorithm...")
# Upsamples data by a factor of 4 to improve peak index resolution
self.ecg_resampled = resample(
self.ecg_filtered,
len(self.ecg_filtered) * self.resample_factor)
self.ecg_scaled = heartpy.scale_data(
[float(i) for i in self.ecg_resampled])
# Processes data using standard heartpy processing
self.wd, self.summary = heartpy.process(
hrdata=self.ecg_scaled,
sample_rate=self.signal_frequency * self.resample_factor)
# Retrieves peaks that got removed in check process
for peak in self.wd["peaklist"]:
if peak not in self.wd["peaklist_cor"]:
self.corrected_peaks.append(peak)
# Creates a timestamp for every beat using peak indexes
for peak in self.wd["peaklist_cor"]:
self.beat_timestamps.append(self.starttime + timedelta(
seconds=peak / (self.signal_frequency * self.resample_factor)))
print("Peak detection complete.")
def resamples(data, filtered, sample_rate):
"""
функция для нормализации сигнала
:param data: исходные данные
:param filtered: отфильтрованный сигнал
:param sample_rate: шаг
:return: wd -содержит пары пиков и множество других характеристик сигнала, m - статистика по сигналу
"""
resampled_data = resample(data, len(filtered))
#scale_data - функция, которая масштабирует передаваемые данные так, чтобы они указали границы
#в любом другом исполнении не работает
print(hp.scale_data(resampled_data))
wd, m = hp.process(hp.scale_data(resampled_data), sample_rate * 2)
# plt.figure(figsize=(12, 4))
# hp.plotter(wd, m)
return wd, m
def get_bpm(ecg_signal, sample_rate):
"""
calculate bpm filtering the signal and upsampling it for better results
:param ecg_signal: 1 lead from an ecg
:param sample_rate: the sample rate of the ecg
:param start_at: this defines the start portion of the ecg that you want to analyse
:param finish_at: this defines the end portion of the ecg that you want to analyse
:return: the bpm for the given sequence
"""
upsampled = scipy.signal.resample(ecg_signal, len(ecg_signal) * 4)
wd, m = hp.process(hp.scale_data(upsampled), sample_rate * 4)
for measure in m.keys():
if measure == 'bpm':
return m[measure]
def wave_slicing(sig_data, pre_num, after_num, fs, slices_num):
data_length = slices_num *(pre_num + after_num)
if sig_data.shape[0] < data_length :
print('data is less than ', data_length )
return np.array()
sig_data = denoise(sig_data[0:data_length])
#print('sig_data shape',sig_data.shape)
#print(sig_data)
data_scale = hp.scale_data(sig_data)
record_sliced = []
try:
# get the location of R wave
working_data, measures = hp.process(hrdata= data_scale,
sample_rate = fs,
bpmmin=5, bpmmax= 300)
# get index of R waves
peaklists = working_data['peaklist']
# remove the first one and last one
peaklists = peaklists[1:-1]
print("index of R waves：", peaklists , '\n len(peaklists):', len(peaklists))
# get the wave
for i in peaklists[0:slices_num]:
#print(i)
tem_data = data_scale[i - pre_num: i + after_num]
#print('sliced data shape', tem_data.shape)
#print('tem_data type:', type(tem_data))
record_sliced.append(tem_data)
#print('append tem_data')
#plot sample
#plt.plot(record_sliced[-1])
#title = str(peaklists[-1])
#plt.title(title)
#plt.show()
record_sliced = np.array(record_sliced).T
print('record_sliced shape:',record_sliced.shape)
except Exception as e:
print('error:', e)
return record_sliced
def run_analysis(self, plot=False):
# Filter the signal
filtered = hp.filter_signal(self.data,
cutoff=0.05,
sample_rate=self.sample_rate,
filtertype='notch')
# Run analysis
wd, m = hp.process(hp.scale_data(filtered), self.sample_rate)
if plot:
# Visualise in plot of custom size
plt.figure(figsize=(12, 4))
hp.plotter(wd, m)
# Display computed measures
for measure in m.keys():
print('%s: %f' % (measure, m[measure]))
return m
def process_ecg(data, show=False, framerate=BASE_FREQUENCY):
filtered = hp.filter_signal(data, [0.7, 3.5],
sample_rate=framerate,
order=3,
filtertype='bandpass')
#filtered = hp.remove_baseline_wander(filtered, FREQUENCY)
wd, m = hp.process(hp.scale_data(filtered), framerate)
if show:
print(wd.keys())
print(m.keys())
hp.plotter(wd, m)
save_plot(wd["breathing_signal"],
str(framerate) + "breathing_signal_hp.png",
framerate,
x_label='Time (' + str(framerate) + 'hz)',
y_label='Breathing Signal')
hr = m["bpm"]
rr = m["breathingrate"]
RR_list = wd["RR_list"]
return hr, rr, RR_list
from keras.callbacks import ReduceLROnPlateau
from keras.constraints import max_norm
from sklearn.model_selection import train_test_split
import pywt
import datetime
label_records[0].p_signal
#!pip install heartpy
#!pip install heartpy
import heartpy as hp
import pandas as pd
import matplotlib.pyplot as plt
data = hp.scale_data(label_records[0].p_signal.T[0])
data0 = label_records[0].p_signal.T[0]
data0.shape
# get the location of R wave
working_data, measures = hp.process(data, 1000.0)
hp.plotter(working_data, measures)
# get index of R waves
peaklists = working_data['peaklist']
# remove the first one and last one
peaklists = peaklists[1:-1]
print("index of R waves：", peaklists)
# get the wave