Signal Transformations

Discrete Cosine Transformations

from vitalDSP.transforms.discrete_cosine_transform import DiscreteCosineTransform
import numpy as np
import os
from vitalDSP.notebooks import load_sample_ecg_small, plot_trace
import plotly.io as pio
pio.renderers.default = "sphinx_gallery"
# pio.renderers.default = "jupyterlab"  # or "plotly_mimetype"
# from IPython.display import display, HTML
# display(HTML('<script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js"></script>'))
signal_col, date_col = load_sample_ecg_small()
signal_col = np.array(signal_col)

dct = DiscreteCosineTransform(signal_col)
dct_coefficients = dct.compute_dct()
compressed_coefficients = dct.compress_signal(threshold=0.05)
reconstructed_signal = dct.compute_idct(compressed_coefficients)
plot_trace(signal_col,reconstructed_signal)

# Feature extraction: Energy distribution in low-frequency components
low_freq_energy = np.sum(dct_coefficients[:20]**2)
total_energy = np.sum(dct_coefficients**2)
low_freq_ratio = low_freq_energy / total_energy

print("Low Frequency Energy Ratio:", low_freq_ratio)

Low Frequency Energy Ratio: 0.003051933817378257

from vitalDSP.transforms.discrete_cosine_transform import DiscreteCosineTransform
import numpy as np
import os
from vitalDSP.notebooks import load_sample_ppg, plot_trace


signal_col, date_col = load_sample_ppg()
signal_col = np.array(signal_col)

dct = DiscreteCosineTransform(signal_col)
dct_coefficients = dct.compute_dct()

# Zero out small coefficients (noise reduction)
compressed_coefficients = dct.compress_signal(threshold=0.1)

# Reconstruct the signal from filtered DCT coefficients
ppg_reconstructed = dct.compute_idct(compressed_coefficients, norm='ortho')

plot_trace(signal_col, ppg_reconstructed)

Fourier Transform

from vitalDSP.transforms.fourier_transform import FourierTransform
import numpy as np
import matplotlib.pyplot as plt
import os
from vitalDSP.notebooks import load_sample_ecg_small, plot_trace


signal_col, date_col = load_sample_ecg_small()
signal_col = np.array(signal_col)

ft = FourierTransform(signal_col)
filtered_signal = ft.filter_frequencies(low_cutoff=0.3, high_cutoff=1.5)
plot_trace(signal_col,filtered_signal)

# Plot the frequency spectrum
fs=128
ecg_freq_content = ft.compute_dft()
freqs = np.fft.fftfreq(len(signal_col), d=1/fs)
plt.plot(freqs[:len(freqs)//2], np.abs(ecg_freq_content)[:len(freqs)//2])
plt.title("ECG Frequency Spectrum")
plt.xlabel("Frequency (Hz)")
plt.ylabel("Amplitude")
plt.show()

Hilbert Transform

from vitalDSP.transforms.hilbert_transform import HilbertTransform
import numpy as np
import plotly.graph_objects as go
import os
from vitalDSP.notebooks import load_sample_ecg_small, plot_trace


signal_col, date_col = load_sample_ecg_small()
signal_col = np.array(signal_col)

# Apply Hilbert Transform
ht = HilbertTransform(signal_col)
analytic_signal = ht.compute_hilbert()
# Compute the envelope of the ECG signal
envelope_ecg = ht.envelope()
# Compute the instantaneous phase of the ECG signal
phase_ecg = ht.instantaneous_phase()
print("ECG Analytic Signal:", analytic_signal)
fig = go.Figure()
fig.add_trace(go.Scatter(y=envelope_ecg, mode="lines", name="envelope_ecg"))
fig.add_trace(go.Scatter(y=phase_ecg, mode="lines", name="phase_ecg"))
# fig.show()  # Auto-rendered in Sphinx

print("ECG Envelope:", envelope_ecg)
print("ECG Instantaneous Phase:", phase_ecg)
plot_trace(signal_col,np.real(analytic_signal))

ECG Analytic Signal: [-87.+193.80416245j -80.+121.85662402j -99.+135.08802775j ...
  48.+106.96202906j  53.+112.74135099j  44.+199.95603753j]
ECG Envelope: [212.43599832 145.77049364 167.48067124 ... 117.2385417  124.57773566
 204.73987629]
ECG Instantaneous Phase: [1.99274075 2.15173386 2.20323434 ... 1.14897624 1.13135142 1.35419989]

Vital Transform

from vitalDSP.transforms.vital_transformation import VitalTransformation
import numpy as np
import matplotlib.pyplot as plt
import os
from vitalDSP.notebooks import load_sample_ecg_small, plot_trace

fs = 128
signal_type = 'ecg'

signal_col, date_col = load_sample_ecg_small()
signal_col = np.array(signal_col)

options = {
    'artifact_removal': 'baseline_correction',
    'artifact_removal_options': {'cutoff': 0.5},
    'bandpass_filter': {'lowcut': 0.2, 'highcut': 10, 'filter_order': 4, 'filter_type': 'butter'},
    'detrending': {'detrend_type': 'linear'},
    'normalization': {'normalization_range': (0, 20)},
    'smoothing': {'smoothing_method': 'moving_average', 'window_size': 5, 'iterations': 2},
    'enhancement': {'enhance_method': 'square'},
    'advanced_filtering': {'filter_type': 'kalman_filter', 'options': {'R': 0.1, 'Q': 0.01}},
    }
method_order = ['artifact_removal', 'bandpass_filter', 'detrending', 'normalization', 
                'smoothing', 'enhancement','advanced_filtering']
transformer = VitalTransformation(signal_col, fs=fs, signal_type=signal_type)
transformed_signal = transformer.apply_transformations(options, method_order)
plot_trace(signal_col, transformed_signal)