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 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
def plot_peaks(self):
"""Runs heartpy.plotter for visualizing filtered data and peaks."""
heartpy.plotter(working_data=self.wd, measures=self.summary)
import heartpy as hp
import numpy
import csv
# convert txt file to csv
#txt_file_address = 'E:\\Lithic\\data\\heart\\heart-bill.txt'
txt_file_address = 'HR_2019-09-22T14-19-17.txt'
csv_file_address = txt_file_address.replace('txt','csv')
in_txt = csv.reader(open(txt_file_address, "r"), delimiter = ',')
out_csv = csv.writer(open(csv_file_address, 'w'))
out_csv.writerows(in_txt)
print(csv_file_address)
hrdata = hp.get_data(csv_file_address, column_name='Analog1_chB')
timerdata = hp.get_data(csv_file_address, column_name='Timestamp')
working_data, measures = hp.process(hrdata, hp.get_samplerate_mstimer(timerdata))
hp.plotter(working_data, measures, title='good plot')
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
records_sliced = []
for i in peaklists:
tem_data = data0[i - 400:i + 600]
records_sliced.append(tem_data)
plt.plot(tem_records_sliced[0])
sample_rate=_sampleRate,
order=3,
return_top=False)
plt.figure(figsize=(22, 6))
plt.plot(filtered_ppg)
plt.show()
wd, m = hp.process(filtered_ppg,
sample_rate=_sampleRate,
high_precision=True,
clean_rr=True,
clean_rr_method='iqr')
plt.figure(figsize=(22, 6))
hp.plotter(wd, m)
for dict_value in m:
for k, v in m.items():
m[k] = round(v, 1)
m.keys
for key in m.keys():
print('%s: %f' % (key, m[key]))
#wd['RR_list']
#wd['peaklist_cor']
#wd['peaklist']
#wd['binary_peaklist']
def medicion_ritmo_cardiaco():
# Comencemos con nuestro primer ejemplo
# Señal capturada con un pulsómetro con la técnica
# de fotoplestimografía (PPG).
data, timer = hp.load_exampledata(0)
sample_rate = 100
plt.figure()
plt.plot(data)
plt.title("Ritmo cardíaco: Ejemplo 1")
plt.legend(['ritmo cardíaco'])
plt.ylabel('pulsos')
plt.xlabel('muestras')
plt.show()
# Utilizaremos la libreria scipy para detectar picos
# https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html
sample_rate = 100
peaks, _ = find_peaks(data, distance=50)
# Plotear los picos
plt.figure()
plt.plot(data)
plt.plot(peaks, data[peaks], "x")
plt.title("Ritmo cardíaco: Ejemplo 1")
plt.legend(['ritmo cardíaco', 'pulsos'])
plt.ylabel('pulsos')
plt.xlabel('muestras')
mplcursors.cursor(multiple=True)
plt.show()
# Calcular el ritmo cardíaco como la diferencia
# de tiempo entre los picos
delta_time_rate = np.diff(peaks)
delta_time = delta_time_rate / sample_rate
promedio = np.mean(delta_time)
pulsaciones_por_minuto = promedio * 60
print("Pulsaciones", pulsaciones_por_minuto)
# Ahora veamos un ejemplo más real de uso, en donde se puede
# ver el ruido introducido por la colocación del instrumento
# y los movimientos del paciente.
data, timer = hp.load_exampledata(1)
sample_rate = hp.get_samplerate_mstimer(timer)
plt.figure()
peaks, _ = find_peaks(data, distance=sample_rate / 2.0)
plt.plot(data)
plt.plot(peaks, data[peaks], "x")
plt.title("Ritmo cardíaco: Ejemplo 2")
plt.legend(['ritmo cardíaco', 'pulsos'])
plt.ylabel('pulsos')
plt.xlabel('muestras')
mplcursors.cursor(multiple=True)
plt.show()
delta_time = np.diff(peaks) / 100
promedio = np.mean(delta_time)
pulsaciones_por_minuto = promedio * 60
print("Pulsaciones", pulsaciones_por_minuto)
# Buscar picos que prevalezcan superiores a su entorno por más del tiempo
# definido (medio ciclo de la señal) --> "prominencia"
peaks, properties = find_peaks(data, prominence=1, width=sample_rate / 2.0)
plt.figure()
plt.plot(data)
plt.plot(peaks, data[peaks], "x")
plt.vlines(x=peaks,
ymin=data[peaks] - properties["prominences"],
ymax=data[peaks],
color="C1")
plt.hlines(y=properties["width_heights"],
xmin=properties["left_ips"],
xmax=properties["right_ips"],
color="C1")
mplcursors.cursor(multiple=True)
plt.show()
# Veamos ahora el potencial de heartpy
# Autor: Paul van Gent
# https://github.com/paulvangentcom/heartrate_analysis_python/blob/master/examples/1_regular_PPG/Analysing_a_PPG_signal.ipynb
# Ejemplo 1
data, timer = hp.load_exampledata(0)
sample_rate = 100
wd, m = hp.process(data, sample_rate=sample_rate)
hp.plotter(wd, m)
print("Pulsaciones", m['bpm'])
# Ejemplo 2
data, timer = hp.load_exampledata(1)
sample_rate = hp.get_samplerate_mstimer(timer)
wd, m = hp.process(data, sample_rate=sample_rate)
hp.plotter(wd, m)
print("Pulsaciones", m['bpm'])
unpack=True)
EDA_df = pd.read_csv('NodeJS/CSV/Participant{0}EDA{1}{2}.csv'.format(
args.participantID, testType, dataType),
delimiter=';')
working_data, measures = hb.process(BVP_numpy,
64.0,
report_time=True,
calc_freq=True)
processed_eda = nk.eda_process(EDA_df["EDA"], freq=1.9, sampling_rate=4)
path = "BaselineData/Participant{0}/".format(args.participantID)
if not os.path.exists(path):
os.makedirs(path)
hb.plotter(working_data, measures)
print("Average heartrate(BPM): {0}".format(measures['bpm']))
print("Average HRV(RMSSD): {0} ".format(measures['rmssd']))
print("Average HRV(LF): {0}".format(measures['lf']))
processed_eda["df"].plot()
hr_dict = {}
hr_dict['working_data'] = working_data
hr_dict['measures'] = measures
# Store the baseline dicts to be transported
pickle.dump(hr_dict, open('{0}HRBase'.format(path), 'wb'))
pickle.dump(processed_eda, open('{0}EDABase'.format(path), 'wb'))
plt.show()
def calculate_bvp_f(bvp_data, sample_rate, bvp_time, bvp_chunks):
features_chunks = []
for chunk in range(len(bvp_chunks)):
if bvp_chunks[chunk] == None:
features_chunks.extend([None])
continue
bvpData = list(map(lambda x: x['data'], bvp_chunks[chunk]))
chunk_time = bvp_chunks[chunk][-1]['timeStamp'] - bvp_chunks[chunk][0][
'timeStamp']
chunk_s_r = len(bvpData) / chunk_time
if not chunk_s_r + 30 >= sample_rate:
features_chunks.extend([None])
continue
bandpass = signalsTools.filter_signal(ftype='FIR',
sampling_rate=chunk_s_r,
band='bandpass',
frequency=[0.5, 4],
signal=bvpData,
order=4)
# all_working_data, all_measures = hp.process(bandpass[0], sample_rate=chunk_s_r,calc_freq=True)
all_working_data, all_measures = hp.process(np.asarray(bvpData),
sample_rate=chunk_s_r)
hp.plotter(all_working_data, all_measures)
result = biosppy.signals.bvp.bvp(signal=np.asarray(bvpData),
sampling_rate=chunk_s_r,
show=True)
result = fd.welch_psd(nni=np.asarray(bvpData))
# RRI_DF = getRRI(np.asarray(bvpData), column2, sample_rate)
# HRV_DF = getHRV(RRI_DF, np.mean(HR))
# print(result['fft_total'])
result.fft_plot()
f, Pxx_den = signal.welch(np.asarray(bvpData))
plt.semilogy(f, Pxx_den)
plt.ylim([0.5e-3, 1])
plt.xlabel('frequency [Hz]')
plt.ylabel('PSD [V**2/Hz]')
plt.show()
plt.plot(all_working_data['RR_list'])
plt.show()
# features = {
# 'HR_avg': all_measures['bpm'],
# 'NN_avg': all_measures['ibi'],
# 'SDNN': all_measures['sdnn'],
# 'SDSD': all_measures['sdsd'],
# 'RMSSD': all_measures['rmssd'],
# 'pNN20': all_measures['pnn20'],
# 'pNN50': all_measures['pnn50'],
# 'hrMad': all_measures['hr_mad'],
# 'BreR': all_measures['breathingrate'],
# 'lf': all_measures['lf'],
# 'hf': all_measures['hf'],
# 'lf/hf': all_measures['lf/hf']
# }
time_domain_features = get_time_domain_features(
all_working_data['RR_list'])
freq_domain_features = get_frequency_domain_features(
all_working_data['RR_list'])
sampen_domain_features = get_sampen(all_working_data['RR_list'])
features = {
'co_he':
freq_domain_features['total_power'] /
(freq_domain_features['hf'] + freq_domain_features['lf'])
}
features.update(time_domain_features)
features.update(freq_domain_features)
features.update(sampen_domain_features)
# features.update({'ApEN':get_apen(all_working_data['RR_list'], 2, (0.2 * features['SDNN']))})
features.update({
'ApEN':
get_apen(all_working_data['RR_list'], 2, (0.2 * features['sdnn']))
})
# samp_enn = sampen2(all_working_data['RR_list'])
# features['sampEn'] = samp_enn['sampen']
SD1 = (1 / np.sqrt(2)) * features[
'sdsd'] # measures the width of poincare cloud https://github.com/pickus91/HRV/blob/master/poincare.py
SD2 = np.sqrt(
(2 * features['sdnn']**2) -
(0.5 *
features['sdsd']**2)) # measures the length of the poincare cloud
features['SD1'] = SD1
features['SD2'] = SD2
features_chunks.extend([features])
return features_chunks
