def visualize_dataset(dataset_path, plot):
data = np.genfromtxt(dataset_path, delimiter=',')
breath_signal = data[:, 1].flatten()
# Plot
fig, ax2 = plt.subplots(1, 1)
sample_freq = 200
breath_signal = normalize(breath_signal)
breath_butter_filter = SimpleSplineFilter()
breath_filtered = stupid_local_norm(
breath_butter_filter.calc_feature(breath_signal))
print(breath_filtered.shape)
print(breath_signal.shape)
# tck = interpolate.splrep(np.arange(breath_filtered1.size)[::40], breath_filtered1[::40], s=25.0)
# breath_filtered = interpolate.splev(np.arange(breath_filtered1.size), tck, der=0)
# GT breath signal
# breath_filtered = normalize(breath_filtered)
((breath_peak_idx, breath_peak_val, breath_peak_period),
(breath_trough_idx, breath_trough_val,
breath_trough_period)) = WindowPeakTroughPoints().calc_feature(
breath_filtered, delta=0.1, lookahead=200)
# ax2.plot(breath_trough_idx, np.reciprocal(breath_trough_period/sample_freq)*60, '+-', label="Thermistor Trough to Trough Frequency")
ax2.plot(breath_trough_idx,
-breath_trough_val,
'.',
markersize=10,
label="Thermistor Trough to Trough Frequency")
ax2.plot(breath_peak_idx,
-breath_peak_val,
'.',
markersize=10,
label="Thermistor Trough to Trough Frequency")
ax2.plot(-breath_filtered, label="Filtered Thermistor")
ax2.plot(np.arange(breath_signal.size)[::2],
breath_signal[::2],
'+',
label="Raw Thermistor")
plt.legend()
plt.xlabel("Samples (at 200Hz)")
plt.ylabel("RR in bpm")
plt.title("Thermistor RR")
plt.show()
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
def visualize_models(input_path, model_jsons):
# Parse the input data
data = h5py.File(input_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size / sampling_rate, input_signal.size)
# Reconstruct the models
models = [build_model(sampling_rate, x) for x in model_jsons]
models_out = []
for model in models:
models_out.append(model(input_signal))
# Visualize raw outputs
fig, ax = plt.subplots(1, 1)
target_signal = normalize(target_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45
}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {
"local_window_length": 40
}).calc_feature(filtered_target)
ax.set_title("Model Output")
for i, model in enumerate(models):
ax.plot(ts, models_out[i], label=model.name)
ax.plot(ts, filtered_target, label="Filtered Thermistor")
ax.set_xlabel("Time in seconds")
plt.legend()
plot_max()
fig, ax = plt.subplots(1, 1)
bpm = thermistor.instant_bpm(target_signal,
sampling_rate,
interpolate=False)
ax.plot(bpm[0], bpm[1], '+-', linewidth=0.5, label="Thermistor RR")
for i, model in enumerate(models):
predicted = thermistor.instant_bpm(models_out[i],
sampling_rate,
interpolate=False)
ax.plot(predicted[0],
predicted[1],
'+-',
linewidth=0.5,
label=model.name)
plt.legend()
plt.xlabel("Time in s")
plt.ylabel("RR in bpm")
plt.title("Predicted vs Thermistor RR")
plot_max()
def visualize_stft_extractor(input_path, model_json, thing):
font = {'family' : 'normal',
'size' : 16}
matplotlib.rc('font', **font)
# Parse the input data
data = h5py.File(input_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size/sampling_rate, input_signal.size)
# Reconstruct the model
model = build_model(sampling_rate, model_json)
model_out = model(input_signal)
target_signal = normalize(target_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {'local_window_length':60/200,'ds':20,'s':45}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {"local_window_length":40}).calc_feature(filtered_target)
centroid = thermistor.stft_centroid_bpm(model_out, sampling_rate)
tcentroid = thermistor.stft_centroid_bpm(target_signal, sampling_rate)
fig, (ax, ax1) = plt.subplots(1,2)
ax.plot(ts, centroid, label="Predicted Centroid RR")
ax.plot(ts, tcentroid, label="Target Centroid RR")
ax.set_xlabel("Time in s")
ax.set_ylabel("RR in bpm")
# ax.set_title("STFT Centroid of {} and Thermistor on {}".format(model.name, os.path.basename(input_path).split('.')[-2]))
ax.set_title("{}: STFT Centroid of {} and Thermistor".format(thing, model.name))
plt.legend()
# plot_max()
rmean_sq_error_centroid = np.sqrt(np.mean((tcentroid-centroid)**2))
model_bpm = thermistor.instant_bpm(model_out)
t_bpm = thermistor.instant_bpm(target_signal)
# fig, ax = plt.subplots(1,1)
ax1.plot(ts, model_bpm, label="Predicted Instant RR")
ax1.plot(ts, t_bpm, label="Target Instant RR")
ax1.set_xlabel("Time in s")
ax1.set_ylabel("RR in bpm")
# ax1.set_title("{}: Instant RR of {} and Thermistor".format(model.name, os.path.basename(input_path).split('.')[-2]))
ax1.set_title("{}: Instant RR of {} and Thermistor".format(thing, model.name))
plt.legend()
plot_max()
rmean_sq_error_bpm = np.sqrt(np.mean((t_bpm-model_bpm)**2))
print("Root Mean Squared Error of Centroid: {}".format(rmean_sq_error_centroid))
print("Root Mean Squared Error of Instant BPM: {}".format(rmean_sq_error_bpm))
def peak_trough_points(breath_signal, sample_freq=200):
breath_signal = normalize(breath_signal)
breath_filtered = SimpleSplineFilter(sample_freq, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45.0
}).calc_feature(breath_signal)
breath_filtered = SimpleLocalNorm(sample_freq, [], {
'local_window_length': 10000 / 200
}).calc_feature(breath_filtered)
breath_filtered = normalize(breath_filtered)
((breath_peak_idx, breath_peak_val, breath_peak_period),
(breath_trough_idx, breath_trough_val,
breath_trough_period)) = OldPeakTroughPoints().calc_feature(
breath_filtered, delta=1.0, lookahead=100)
return ((breath_peak_idx, breath_peak_val, breath_peak_period),
(breath_trough_idx, breath_trough_val, breath_trough_period))
def visualize_model(input_path, model_json):
# Parse the input data
data = h5py.File(input_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size / sampling_rate, input_signal.size)
# Reconstruct the model
model = build_model(sampling_rate, model_json)
target_signal = normalize(target_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45
}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {
"local_window_length": 40
}).calc_feature(filtered_target)
# Loop over all features and plot them against thermistor output and raw input
print(model.get_names())
print(model.get_list())
for (name, feature) in zip(model.get_names(), model.get_list()):
print(name)
# visualize raw output
feature_out = feature.calc_feature(input_signal)
fig, ax = plt.subplots(1, 1)
ax.set_title("Feature: {}".format(name))
ax.plot(ts, feature_out, label=name)
ax.plot(ts, filtered_target, label="thermistor")
# ax.plot(ts, normalize(input_signal), label="input")
ax.set_xlabel("time in seconds")
plt.legend()
plt.show()
# plot_max()
print(name)
def visualize_stft_extractor(input_path, model_json):
# Parse the input data
data = h5py.File(input_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size / sampling_rate, input_signal.size)
# Reconstruct the model
model = build_model(sampling_rate, model_json)
model_out = model(input_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45
}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {
"local_window_length": 40
}).calc_feature(filtered_target)
# Visualize STFT
max_freq = 30 / 60
downsample = 2
f, t, Zxx = signal.stft(model_out[::downsample],
fs=sampling_rate / downsample,
nperseg=8000 // downsample,
noverlap=8000 // downsample - 10,
boundary=None)
bf, bt, bZxx = signal.stft(filtered_target[::downsample],
fs=sampling_rate / downsample,
nperseg=8000 // downsample,
noverlap=8000 // downsample - 10,
boundary=None)
max_bin = np.searchsorted(f, max_freq)
min_bin = 2
fig, ax = plt.subplots(2, 1)
ax[0].pcolormesh(bt, bf[min_bin:max_bin] * 60,
np.log(1 + np.abs(bZxx)[min_bin:max_bin]))
ax[1].pcolormesh(t, f[min_bin:max_bin] * 60,
np.log(1 + np.abs(Zxx)[min_bin:max_bin]))
# Argmax in frequency
bmaxbins = np.argmax(np.abs(bZxx)[min_bin:max_bin], axis=0) + min_bin
# Histogram correction
# ax[0].plot(bt, (bf[bmaxbins]+bf[bmaxbins+1])/2*60, 'r-')
maxbins = np.argmax(np.abs(Zxx)[min_bin:max_bin], axis=0) + min_bin
# ax[1].plot(t, (f[maxbins]+f[maxbins+1])/2*60, 'r-')
ax[0].set_title("Thermistor STFT P=3 Centroid")
ax[1].set_title("Prediction STFT P=3 Centroid")
ax[0].set_ylabel("RR in bpm")
ax[1].set_xlabel("Time in s")
ax[1].set_ylabel("RR in bpm")
def centroid(Z, f, axis=0, p=1):
Z = np.power(Z, p)
a = f
if (axis == 0):
centroid = np.dot(np.transpose(Z), a) / np.sum(Z, axis=axis)
elif (axis == 1):
centroid = np.dot(Z, a) / np.sum(Z, axis=axis)
return centroid
# Centroid in frequency
bcentroid = centroid(np.log(1 + np.abs(bZxx))[min_bin:max_bin],
bf[min_bin:max_bin],
axis=0,
p=3)
ax[0].plot(t, bcentroid * 60, 'r-')
centroid = centroid(np.log(1 + np.abs(Zxx))[min_bin:max_bin],
f[min_bin:max_bin],
axis=0,
p=3)
ax[1].plot(t, centroid * 60, 'r-')
"""
"""
plot_max()
def visualize_dataset(dataset_path, plot):
data = h5py.File(dataset_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size/sampling_rate, input_signal.size)
# Plot the raw signal
fig, ax = plt.subplots(2,1)
ax[0].set_title("Raw Input Signal")
ax[0].plot(ts, input_signal, label="Raw Input Signal")
ax[1].set_title("Raw Target Signal")
ax[1].plot(ts, target_signal, label="Raw Target Signal")
ax[0].set_xlabel("Time in seconds")
ax[1].set_xlabel("Time in seconds")
plot_max()
# SimpleLocalNorm
input_signal = normalize(input_signal)
local_input_signal = SimpleLocalNorm(sampling_rate, [], {'local_window_length': 20}).calc_feature(input_signal)
fig, ax = plt.subplots(2,1)
ax[0].set_title("Norm Input Signal")
ax[0].plot(ts, input_signal, label="Norm Input Signal")
ax[1].set_title("SimpleLocalNorm of Norm Input Signal")
ax[1].plot(ts, local_input_signal, label="SimpleLocalNorm")
ax[0].set_xlabel("Time in seconds")
ax[1].set_xlabel("Time in seconds")
plot_max()
# SimpleButterFilter
filtered_input = SimpleButterFilter(sampling_rate, [], {'low_cut': 3/60, 'high_cut': 90/60, 'order': 3}).calc_feature(input_signal)
fig, ax = plt.subplots(2,1)
ax[0].set_title("Norm Input Signal")
ax[0].plot(ts, input_signal, label="Norm Input Signal")
ax[1].set_title("SimpleButterFilter of Norm Input Signal")
ax[1].plot(ts, filtered_input, label="SimpleButterFilter")
ax[0].set_xlim(0,100)
ax[1].set_xlim(0,100)
ax[0].set_xlabel("Time in seconds")
ax[1].set_xlabel("Time in seconds")
plot_max()
# SimpleSplineFilter
norm_target = SimpleLocalNorm(sampling_rate, [], {'local_window_length': 80}).calc_feature(input_signal)
norm_target = normalize(norm_target)
filtered_target = SimpleSplineFilter(sampling_rate, [], {'local_window_length': 30/200, 'ds': 20, 's': 35.0}).calc_feature(norm_target)
alt_filtered_target = SimpleButterFilter(sampling_rate, [], {'low_cut': 3/60, 'high_cut': 40/60, 'order': 2}).calc_feature(norm_target)
fig, ax = plt.subplots(1,1)
ax.set_title("SimpleSplineFilter on Input Signal")
ax.plot(ts, norm_target, '+', label="Norm Input Signal")
ax.plot(ts, filtered_target, label="SimpleSplineFilter")
ax.plot(ts, alt_filtered_target, label="SimpleButterFilter")
ax.set_xlim(0,200)
ax.set_xlabel("Time in seconds")
plt.legend()
plot_max()
# WindowPeakTroughPeriods
pisp = WindowPeakTroughPeriods(sampling_rate, [], {'lookahead_length': 5/200, 'delta': 0.02, 'interp': 'spline', 's': 0, "toggle_p_t": True}).calc_feature(filtered_input)
pist = WindowPeakTroughPeriods(sampling_rate, [], {'lookahead_length': 5/200, 'delta': 0.02, 'interp': 'spline', 's': 0, "toggle_p_t": False}).calc_feature(filtered_input)
fig, ax = plt.subplots(1,1)
ax.set_title("SimpleSplineFilter on Target Signal")
ax.plot(ts, normalize(pisp), label="PISP")
ax.plot(ts, normalize(pist), label="PIST")
ax.plot(ts, filtered_target, label="Filtered Target")
ax.set_xlim(0,400)
ax.set_ylim(-5,5)
ax.set_xlabel("Time in seconds")
plt.legend()
plot_max()
# WindowEnvelopesAmplitude
ase = WindowEnvelopesAmplitude(sampling_rate, [], {'lookahead_length': 5/200, 'delta': 0.02}).calc_feature(filtered_input)
fig, ax = plt.subplots(1,1)
ax.set_title("Amplitude by Spline Envelopes on Filtered Input")
ax.plot(ts, normalize(ase), label="Amplitude by Spline Envelopes")
ax.plot(ts, filtered_target, label="Filtered Target")
ax.set_xlim(0,400)
ax.set_ylim(-5,5)
ax.set_xlabel("Time in seconds")
plt.legend()
plot_max()
# Instant BPM
bpm = thermistor.instant_bpm(target_signal, sampling_rate)
fig, ax = plt.subplots(1,1)
ax.plot(ts, bpm, label="Filtered Target")
plot_max()
def visualize_model(input_path, model_json):
# Parse the input data
data = h5py.File(input_path, 'r')['data']
input_signal = data['signal']
target_signal = data['target']
sampling_rate = data.attrs['sampling_rate']
ts = np.linspace(0, input_signal.size / sampling_rate, input_signal.size)
# Reconstruct the model
model = build_model(sampling_rate, model_json)
# Visualize raw output
model_out = model(input_signal)
fig, ax = plt.subplots(2, 1)
ax[0].set_title("Model Output")
ax[0].plot(ts, model_out, label="Raw Input Signal")
ax[1].set_title("Raw Target Signal")
ax[1].plot(ts, target_signal, label="Raw Target Signal")
ax[0].set_xlabel("Time in seconds")
ax[1].set_xlabel("Time in seconds")
plot_max()
fig, ax = plt.subplots(1, 1)
target_signal = normalize(target_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45
}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {
"local_window_length": 40
}).calc_feature(filtered_target)
ax.set_title("Model Output")
ax.plot(ts, model_out, label="Raw Model Output")
ax.plot(ts, filtered_target, label="Filtered Thermistor")
ax.set_xlabel("Time in seconds")
plt.legend()
plot_max()
# Visualize STFT
fig, ax = plt.subplots(2, 1)
max_freq = 30 / 60
downsample = 2
f, t, Zxx = signal.stft(model_out[::downsample],
fs=sampling_rate / downsample,
nperseg=12000 // downsample,
noverlap=12000 // downsample - 10,
boundary=None)
bf, bt, bZxx = signal.stft(filtered_target[::downsample],
fs=sampling_rate / downsample,
nperseg=12000 // downsample,
noverlap=12000 // downsample - 10,
boundary=None)
max_bin = np.searchsorted(f, max_freq)
ax[0].pcolormesh(bt, bf[2:max_bin] * 60,
np.log(1 + np.abs(bZxx)[2:max_bin]))
ax[0].set_title("Thermistor")
ax[1].set_xlabel("Time in s")
ax[1].set_ylabel("RR in bpm")
ax[1].pcolormesh(t, f[2:max_bin] * 60, np.log(1 + np.abs(Zxx)[2:max_bin]))
ax[1].set_title("Prediction")
# ax2.set_ylim(f[2]*60, f[max_bin]*60) #f[max_bin]*60)
plot_max()
fig, ax = plt.subplots(1, 1)
bpm = thermistor.instant_bpm(target_signal,
sampling_rate,
interpolate=False)
predicted = thermistor.instant_bpm(model_out,
sampling_rate,
interpolate=False)
ax.plot(bpm[0], bpm[1], label="Thermistor RR")
ax.plot(predicted[0], predicted[1], label="Predicted RR")
plt.legend()
plt.xlabel("Time in s")
plt.ylabel("RR in bpm")
plt.title("Predicted vs Thermistor RR")
plot_max()
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(f, t, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
def visualize_dataset(dataset_path, plot):
data = np.genfromtxt(dataset_path, delimiter=',')
breath_signal = (data[:, 3].flatten() + data[:, 2].flatten()) / 2
target_signal = normalize(target_signal)
filtered_target = SimpleSplineFilter(sampling_rate, [], {
'local_window_length': 60 / 200,
'ds': 20,
's': 45
}).calc_feature(target_signal)
filtered_target = SimpleLocalNorm(sampling_rate, [], {
"local_window_length": 40
}).calc_feature(filtered_target)
# Plot
sample_freq = 200
breath_butter_filter = SimpleSplineFilter(avg_win=60, ds=15, s=45.0)
breath_filtered = stupid_local_norm(
breath_butter_filter.calc_feature(breath_signal), 10000)
breath_filtered = normalize(breath_filtered)
# GT breath signal
((breath_peak_idx, breath_peak_val, breath_peak_period),
(breath_trough_idx, breath_trough_val,
breath_trough_period)) = WindowPeakTroughPoints().calc_feature(
breath_filtered, delta=1.0, lookahead=100)
fig, ax2 = plt.subplots(1, 1)
ax2.plot(breath_trough_idx,
breath_trough_val,
'.',
markersize=20,
label="Thermistor Trough to Trough Frequency")
ax2.plot(breath_peak_idx,
breath_peak_val,
'.',
markersize=20,
label="Thermistor Trough to Trough Frequency")
ax2.plot(breath_filtered, label="Filtered Thermistor")
ax2.plot(np.arange(breath_signal.size)[::5],
breath_signal[::5],
'+',
label="Raw Thermistor")
plt.legend()
plt.xlabel("Samples (at 200Hz)")
plt.ylabel("RR in bpm")
plt.title("Thermistor RR")
plt.show()
# Plot result
fig, ax2 = plt.subplots(1, 1)
y = breath_filtered
yp, yt = WindowEnvelopes().calc_feature(y, 300, 1.0, s=3)
ax2.plot(y, label="Filtered Thermistor")
w = np.hanning(8000)
mov_avg = np.convolve(w / w.sum(), y, 'same')
avg_env = mov_avg
ax2.plot(avg_env, label="Min Envelope")
# w = np.hanning(8000)
# mov_avg = np.convolve(w/w.sum(), y, 'same')
ax2.plot(y, label="Filtered Thermistor")
ax2.plot(np.arange(breath_avg.size)[::20],
breath_avg[::20],
'+',
label="Raw Thermistor")
plt.show()
fig, ax2 = plt.subplots(1, 1)
bpm = instant_bpm(breath_signal, sample_freq)
print(bpm.shape)
print(breath_signal.shape)
ax2.plot(bpm)
ax2.plot(np.arange(breath_avg.size)[::20],
breath_avg[::20],
'+',
label="Raw Thermistor")
plt.show()
# fig, ax2 = plt.subplots(1,1)
# ax2.plot(np.gradient(breath_filtered), label="Gradient of Thermistor")
# ax2.plot(breath_filtered, label="Filtered Thermistor")
# plt.legend()
# plt.show()
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
def visualize_dataset(dataset_path, plot):
data = np.genfromtxt(dataset_path, delimiter=',')
ppg_signal = data[:, 1].flatten()
breath_signal = data[:, 3].flatten()
print(ppg_signal.shape)
# Plot
fig, ax2 = plt.subplots(1, 1)
sample_freq = 200
ppg_signal = normalize(ppg_signal)
breath_signal = normalize(breath_signal)
if plot == -2:
# norm_sig = stupid_local_norm(ppg_filtered)
# fig, [ax1,ax2] = plt.subplots(1,2)
# ax1.plot(ppg_signal, "Raw PPG")
ax2.set_title("Raw PPG")
ax2.plot(ppg_signal, label="Raw PPG")
ax2.plot(breath_signal, label="Raw Breath")
plt.legend()
# plt.plot(norm_sig)
plt.show()
# Filter the signals
# ax2.plot(breath_signal)
ppg_butter_filter = SimpleButterFilter(sample_freq,
3 / 60,
90 / 60,
order=3)
ppg_filtered = ppg_butter_filter.calc_feature(ppg_signal)
# ppg_filtered = butter_bandpass_filter(ppg_signal, 3/60, 90/60, sample_freq, order=3)
print(ppg_filtered.shape)
if plot == -1:
norm_sig = stupid_local_norm(ppg_filtered)
fig, [ax1, ax2] = plt.subplots(1, 2)
ax1.plot(ppg_filtered)
ax1.set_title("Filtered PPG")
ax2.plot(norm_sig)
ax2.set_title("Normalized Filtered PPG")
# plt.plot(norm_sig)
plt.show()
ppg_filtered = stupid_local_norm(ppg_filtered)
print(ppg_filtered.shape)
# breath_butter_filter = SimpleButterFilter(sample_freq, 3/60, 50/60, order=5)
# breath_filtered = breath_butter_filter.calc_feature(breath_signal)
# breath_butter_filter = SimpleSplineFilter(avg_win=60, ds=15, s=45.0).calc_feature(breath_signal)
breath_butter_filter = SimpleSplineFilter(avg_win=60, ds=15, s=45.0)
breath_filtered = stupid_local_norm(
breath_butter_filter.calc_feature(breath_signal), 10000)
# breath_filtered = butter_bandpass_filter(breath_signal, 3/60, 30/60, sample_freq, order=2)
# Calc the peaks
ppg_trough_idx, ppg_trough_val, ppg_trough_period = calc_troughs(
ppg_filtered)
ppg_peak_idx, ppg_peak_val, ppg_peak_period = calc_peaks(ppg_filtered)
if plot == 1:
ax2.plot(breath_filtered, label="Filtered PPG")
ax2.plot(ppg_filtered, label="Filtered Thermistor")
plt.legend()
plt.xlabel("Samples")
plt.title("Filtered PPG and Thermistor")
plt.show()
if plot == 2:
ax2.plot(ppg_filtered)
ax2.scatter(ppg_trough_idx, ppg_trough_val)
ax2.scatter(ppg_peak_idx, ppg_peak_val)
plt.xlabel("Samples")
plt.title("Peak detector on filtered ppg")
plt.show()
# Calc the envelopes
# ppg_trough_envelope = interpolate_spline(ppg_trough_idx, ppg_trough_val, np.arange(ppg_filtered.size))
# ppg_peak_envelope = interpolate_spline(ppg_peak_idx, ppg_peak_val, np.arange(ppg_filtered.size))
ppg_envelopes_feature = WindowEnvelopes()
ppg_peak_envelope, ppg_trough_envelope = ppg_envelopes_feature.calc_feature(
ppg_filtered)
ppg_amplitude_feature = WindowEnvelopesAmplitude()
ppg_envelope_amplitude = ppg_amplitude_feature.calc_feature(ppg_filtered)
if plot == 0:
ax2.plot(ppg_signal, label="Raw PPG")
ax2.plot(ppg_peak_envelope)
ax2.plot(ppg_trough_envelope)
ax2.plot(ppg_filtered, label="Filtered PPG")
plt.legend()
plt.xlabel("Samples")
plt.title("Filtered PPG and Thermistor")
plt.show()
if plot == 3:
ax2.plot(ppg_filtered)
ax2.plot(ppg_trough_envelope)
ax2.plot(ppg_peak_envelope)
# ax2.scatter(butter_bandpass_filter(ppg_signal, 3/60, 60/60, sample_freq, order=3))
plt.xlabel("Samples")
plt.title("Spline interpolation to get envelope of ppg")
plt.show()
if plot == 4:
ax2.plot(normalize(breath_filtered), label="Filtered Thermistor")
ax2.plot(3 * normalize(ppg_envelope_amplitude),
label="Amplitude between envelopes")
plt.legend()
plt.xlabel("Samples")
plt.title("Calculate signal amplitude by subtracting envelopes")
plt.show()
"""
interp_ppg_peak_period = np.interp(np.arange(ppg_filtered.size), ppg_peak_idx, normalize(ppg_peak_period))
interp_ppg_trough_period = np.interp(np.arange(ppg_filtered.size), ppg_trough_idx, normalize(ppg_trough_period))
"""
# interp_ppg_peak_period = interpolate_spline(ppg_peak_idx, normalize(ppg_peak_period), np.arange(ppg_filtered.size))
# interp_ppg_trough_period = interpolate_spline(ppg_trough_idx, normalize(ppg_trough_period), np.arange(ppg_filtered.size))
interp_ppg_peak_period, interp_ppg_trough_period = WindowPeakTroughPeriods(
).calc_feature(ppg_filtered)
if plot == 5:
ax2.plot(normalize(breath_filtered), label="Filtered Thermistor")
# ax2.scatter(ppg_peak_idx, normalize(ppg_peak_period), label="Period between peaks")
# ax2.scatter(ppg_trough_idx, normalize(ppg_trough_period), label="Period between troughs")
ax2.plot(normalize(interp_ppg_peak_period),
label="Smoothed period between peaks")
# ax2.plot(interp_ppg_trough_period)
plt.legend()
plt.xlabel("Samples")
plt.title("Period between peaks in filtered ppg")
plt.show()
if plot == 6:
# GT breath signal
breath_filtered = normalize(breath_filtered)
breath_trough_idx, breath_trough_val, breath_trough_period = calc_troughs(
breath_filtered, delta=0.1, lookahead=200)
breath_peak_idx, breath_peak_val, breath_peak_period = calc_peaks(
breath_filtered, delta=0.1, lookahead=200)
"""
# ppg_t_p_trough_idx, ppg_t_p_trough_val, ppg_t_p_trough_period = calc_troughs(interp_ppg_trough_period)
ax2.plot((breath_filtered), label="Filtered Thermistor")
ax2.plot((breath_signal), label="Unfiltered Thermistor")
# ax2.plot(np.reciprocal(interp_breath_peak_period/sample_freq)*60, label="Thermistor Peak to Peak Period")
ax2.scatter(breath_trough_idx, breath_trough_val, label="Thermistor Trough ")
# ax2.scatter(breath_trough_idx, np.reciprocal(breath_trough_period/sample_freq)*60, label="Thermistor Trough to Trough Period", marker="+")
"""
# ax2.scatter(ppg_t_p_trough_idx, np.reciprocal(ppg_t_p_trough_period/sample_freq)*60, label="PIST Feature Trough to Trough Period", marker="+")
from utils.breath_cnn import main
cnn_out = (SimpleButterFilter(sample_freq, 3 / 60, 90 / 60,
order=3).calc_feature(main()))
cnn_trough_idx, cnn_trough_val, cnn_trough_period = calc_troughs(
cnn_out)
cnn_peak_idx, cnn_peak_val, cnn_peak_period = calc_troughs(cnn_out)
"""
ax2.plot(np.arange(cnn_out.size)*8, cnn_out)
ax2.scatter(cnn_trough_idx*8, cnn_trough_val, label="Thermistor Trough ")
ax2.plot((breath_filtered), label="Filtered Thermistor")
ax2.scatter(breath_trough_idx, breath_trough_val, label="Thermistor Trough ")
"""
# ax2.scatter(cnn_trough_idx*8, np.reciprocal(cnn_trough_period*8/sample_freq)*60, label="CNN Out Trough to Trough Period", marker="+")
ax2.plot(breath_trough_idx,
np.reciprocal(breath_trough_period / sample_freq) * 60,
'+-',
label="Thermistor Trough to Trough Frequency")
ax2.plot(cnn_trough_idx * 8,
np.reciprocal(cnn_trough_period * 8 / sample_freq) * 60,
'+-',
label="CNN Out Trough to Trough Frequency")
# ax2.plot(cnn_trough_idx*8, np.reciprocal(cnn_trough_period*8/sample_freq)*60, '+-', label="CNN Out Trough to Trough PFrequencyeriod")
# ax2.plot(interp_breath_trough_period/sample_freq, label="Thermistor Trough to Trough Period")
# ax2.plot(normalize(interp_ppg_peak_period), label="Smoothed period between peaks")
plt.legend()
plt.xlabel("Samples (at 200Hz)")
plt.ylabel("RR in bpm")
plt.title("Predicted vs Thermistor RR`")
plt.show()
"""
n = ppg_filtered.size//3
breath_fft = np.fft.fft(breath_filtered[:n])
ppg_peak_period_fft = np.fft.fft(interp_ppg_peak_period[:n])
ppg_trough_period_fft = np.fft.fft((ppg_peak_envelope-ppg_trough_envelope)[:n])
# max_bin = int(n/sample_freq/2*120)
max_bin = int(200/60/sample_freq*n)
ax2.plot(60*sample_freq/n*np.arange(breath_fft.size)[1:max_bin], normalize(np.abs(breath_fft)[1:max_bin]))
# ax2.plot(60*sample_freq/n*np.arange(breath_fft.size)[1:max_bin], np.abs(ppg_peak_period_fft)[1:max_bin])
# ax2.plot(60*sample_freq/n*np.arange(breath_fft.size)[1:max_bin], np.abs(ppg_trough_period_fft)[1:max_bin])
ax2.plot(60*sample_freq/n*np.arange(breath_fft.size)[1:max_bin], normalize(np.abs(ppg_trough_period_fft)[1:max_bin]))
"""
"""
inhale_period = np.empty_like(inhale_idx)
inhale_period[1:] = np.diff(inhale_idx)
inhale_period[0] = inhale_period[1]
inhale_period = inhale_period/sample_freq
ax2.plot(inhale_idx/sample_freq, np.reciprocal(inhale_period)*60.0, 'r.')
"""
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
def visualize_dataset(dataset_path, plot):
data = np.genfromtxt(dataset_path, delimiter=',')
ppg_signal = data[:,1].flatten()
try:
breath_signal = data[:,3].flatten()
except:
breath_signal = np.zeros_like(ppg_signal)
sample_freq = 40
peak_delta = 0.5
ppg_signal = normalize(ppg_signal)
# ppg_spline_filter = SimpleSplineFilter(ds=15, s=15.0)
# ppg_filtered = stupid_local_norm(ppg_spline_filter.calc_feature(ppg_signal), 8000)
fs0 = SimpleButterFilter(sample_freq,1/60,100/60,order=3).calc_feature(ppg_signal)
# ppg_filtered = stupid_local_norm(fs0)
ppg_filtered = fs0
# ppg_filtered = ppg_signal
'''
ppg_butter_filtered = SimpleButterFilter(sample_freq, 3/60, 90/60, order=2).calc_feature(ppg_signal)
ppg_spline_filter = SimpleSplineFilter().calc_feature(ppg_signal)
fig, ax2 = plt.subplots(1,1)
ax2.plot(ppg_spline_filter, label="Spline Filtered PPG")
ax2.plot(ppg_butter_filtered, label="Butter Filtered PPG")
ax2.plot(ppg_signal, label="Raw PPG")
plt.legend()
plt.show()
'''
breath_signal = normalize(breath_signal)
breath_spline_filter = SimpleSplineFilter(avg_win=40, ds=40, s=15.0)
breath_filtered = stupid_local_norm(breath_spline_filter.calc_feature(breath_signal), 8000)
# tck = interpolate.splrep(np.arange(ppg_filtered1.size)[::40], ppg_filtered1[::40], s=25.0)
# ppg_filtered = interpolate.splev(np.arange(ppg_filtered1.size), tck, der=0)
# GT ppg signal
# ppg_filtered = normalize(ppg_filtered)
# ((ppg_peak_idx, ppg_peak_val, ppg_peak_period),(ppg_trough_idx, ppg_trough_val, ppg_trough_period)) = WindowPeakTroughPoints().calc_feature(ppg_filtered, delta=2.0, lookahead=250)
# ax2.plot(ppg_trough_idx, np.reciprocal(ppg_trough_period/sample_freq)*60, '+-', label="Thermistor Trough to Trough Frequency")
# Plot
fig, ax2 = plt.subplots(1,1)
# ax2.plot(ppg_trough_idx, ppg_trough_val, '.', markersize=10, label="PPG Troughs")
# ax2.plot(ppg_peak_idx, ppg_peak_val, '.', markersize=10, label="PPG Peaks")
ax2.plot(ppg_filtered, label="Filtered PPG")
ax2.plot(ppg_signal, label="Raw PPG")
# ax2.plot(np.arange(ppg_signal.size)[::2], ppg_signal[::2], '+', label="Raw Thermistor")
plt.legend()
plt.xlabel("Samples (at 200Hz)")
plt.ylabel("RR in bpm")
plt.title("Thermistor RR")
plt.show()
# Calculate gradient of PPG
lookahead = int(70/200*sample_freq)
grad_feature = ppg_filtered# stupid_local_norm(ppg_filtered,8000) #np.gradient(stupid_local_norm(ppg_filtered,1000))
((grad_peak_idx, grad_peak_val, grad_peak_period),(grad_trough_idx, grad_trough_val, grad_trough_period)) = WindowPeakTroughPoints().calc_feature(grad_feature, delta=peak_delta, lookahead=lookahead)
fig, ax2 = plt.subplots(1,1)
ax2.plot(grad_feature, label="Gradient of Filtered PPG")
ax2.plot(grad_trough_idx, grad_trough_val, '.', markersize=10, label="PPG Gradient Troughs")
plt.show()
# Interpolate period between troughs
interp_ppg_peak_period, interp_ppg_trough_period = WindowPeakTroughPeriods().calc_feature(grad_feature, delta=peak_delta, lookahead=lookahead, s=165, interp='line')
fig, ax2 = plt.subplots(1,1)
ax2.plot(normalize(breath_filtered), label="Filtered Thermistor")
ax2.plot(normalize(interp_ppg_peak_period), label="Filtered Thermistor")
ax2.plot(normalize(interp_ppg_trough_period), label="Filtered Thermistor")
plt.show()
fig, ax2 = plt.subplots(1,1)
ax2.plot(normalize(breath_filtered), label="Filtered Thermistor")
ax2.plot((normalize(interp_ppg_trough_period) + normalize(interp_ppg_peak_period))/2, label="Filtered Thermistor")
plt.show()
interp_ppg_period = WindowPeakTroughPeriods().calc_feature(grad_feature, delta=peak_delta, lookahead=lookahead, s=165, joint=True)
fig, ax2 = plt.subplots(1,1)
ax2.plot(normalize(breath_filtered), label="Filtered Thermistor")
ax2.plot(normalize(interp_ppg_period), label="Filtered Thermistor")
plt.show()
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()