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()