paradigma 0.1.5__py3-none-any.whl → 0.3.0__py3-none-any.whl

paradigma/heart_rate_analysis.py

@@ -0,0 +1,127 @@
+from typing import List
+import numpy as np
+from scipy.signal import welch
+from sklearn.preprocessing import StandardScaler
+from dateutil import parser
+
+import tsdf
+import tsdf.constants
+from paradigma.heart_rate_analysis_config import HeartRateFeatureExtractionConfig
+from paradigma.heart_rate_util import extract_ppg_features, calculate_power_ratio, read_PPG_quality_classifier
+from paradigma.util import read_metadata, write_data, get_end_iso8601
+from paradigma.constants import DataColumns, UNIX_TICKS_MS
+
+
+def extract_signal_quality_features(input_path: str, classifier_path: str, output_path: str, config: HeartRateFeatureExtractionConfig) -> None:
+    # load data
+    metadata_time_ppg, metadata_samples_ppg = read_metadata(input_path, "PPG_meta.json", "PPG_time.bin", "PPG_samples.bin")
+    df_ppg = tsdf.load_dataframe_from_binaries([metadata_time_ppg, metadata_samples_ppg], tsdf.constants.ConcatenationType.columns)
+    arr_ppg = df_ppg[DataColumns.PPG].to_numpy()
+    relative_time_ppg = df_ppg[DataColumns.TIME].to_numpy()
+    
+    metadata_time_acc, metadata_samples_acc = read_metadata(input_path, "accelerometer_meta.json", "accelerometer_time.bin", "accelerometer_samples.bin")
+    df_acc = tsdf.load_dataframe_from_binaries([metadata_time_acc, metadata_samples_acc], tsdf.constants.ConcatenationType.columns)
+    arr_acc = df_acc[[DataColumns.ACCELEROMETER_X, DataColumns.ACCELEROMETER_Y, DataColumns.ACCELEROMETER_Z]].to_numpy()
+
+    sampling_frequency_ppg = config.sampling_frequency_ppg
+    sampling_frequency_imu = config.sampling_frequency_imu
+
+    # Parameters
+    epoch_length = 6  # in seconds
+    overlap = 5  # in seconds
+
+    # Number of samples in epoch
+    samples_per_epoch_ppg = int(epoch_length * sampling_frequency_ppg)
+    samples_per_epoch_acc = int(epoch_length * sampling_frequency_imu)
+
+    # Calculate number of samples to shift for each epoch
+    samples_shift_ppg = int((epoch_length - overlap) * sampling_frequency_ppg)
+    samples_shift_acc = int((epoch_length - overlap) * sampling_frequency_imu)
+
+    pwelchwin_acc = int(3 * sampling_frequency_imu)  # window length for pwelch
+    pwelchwin_ppg = int(3 * sampling_frequency_ppg)  # window length for pwelch
+    noverlap_acc = int(0.5 * pwelchwin_acc)  # overlap for pwelch
+    noverlap_ppg = int(0.5 * pwelchwin_ppg)  # overlap for pwelch
+
+    f_bin_res = 0.05  # the threshold is set based on this binning
+    nfft_ppg = np.arange(0, sampling_frequency_ppg / 2, f_bin_res)  # frequency bins for pwelch ppg
+    nfft_acc = np.arange(0, sampling_frequency_imu / 2, f_bin_res)  # frequency bins for pwelch imu
+
+    features_ppg_scaled = []
+    feature_acc = []
+    t_unix_feat_total = []
+    count = 0
+    acc_idx = 0
+
+    # Read the classifier (it contains mu and sigma)
+    clf = read_PPG_quality_classifier(classifier_path)
+    # not used here: lr_model = clf['model']
+    arr_mu = clf['mu'][:, 0]
+    arr_sigma = clf['sigma'][:, 0]
+
+    scaler = StandardScaler()
+    scaler.mean_ = arr_mu
+    scaler.scale_ = arr_sigma
+
+    ppg_start_time = parser.parse(metadata_time_ppg.start_iso8601)
+
+    # Loop over 6s segments for both PPG and IMU and calculate features
+    for i in range(0, len(arr_ppg) - samples_per_epoch_ppg + 1, samples_shift_ppg):
+        if acc_idx + samples_per_epoch_acc > len(arr_acc):  # For the last epoch, check if the segment for IMU is too short (not 6 seconds)
+            break
+        else:
+            acc_segment = arr_acc[acc_idx:acc_idx + samples_per_epoch_acc, :]  # Extract the IMU window (6 seconds)
+
+        ppg_segment = arr_ppg[i:i + samples_per_epoch_ppg]  # Extract the PPG window (6 seconds)
+
+        count += 1
+
+        # Feature extraction + scaling
+        features = extract_ppg_features(ppg_segment, sampling_frequency_ppg)
+        features = features.reshape(1, -1)
+        features_ppg_scaled.append(scaler.transform(features)[0])
+
+        # Calculating PSD (power spectral density) of IMU and PPG
+        #hann(pwelchwin_acc)
+        #hann(pwelchwin_ppg)
+        print(pwelchwin_acc, noverlap_acc, len(nfft_acc))
+        f1, pxx1 = welch(acc_segment, sampling_frequency_imu, window='hann', nperseg=pwelchwin_acc, noverlap=None, nfft=len(nfft_acc))
+        PSD_imu = np.sum(pxx1, axis=1)  # sum over the three axes
+        f2, pxx2 = welch(ppg_segment, sampling_frequency_ppg, window='hann', nperseg=pwelchwin_ppg, noverlap=None, nfft=len(nfft_ppg))
+        PSD_ppg = np.sum(pxx2)  # this does nothing, equal to PSD_ppg = pxx2
+
+        # IMU feature extraction
+        print(f1.shape, f2.shape)
+        feature_acc.append(calculate_power_ratio(f1, PSD_imu, f2, PSD_ppg))  # Calculate the power ratio of the accelerometer signal in the PPG frequency range
+
+        # time channel
+        t_unix_feat_total.append((relative_time_ppg[i] + ppg_start_time) * UNIX_TICKS_MS)  # Save in absolute unix time ms
+        acc_idx += samples_shift_acc  # update IMU_idx
+
+    # Convert lists to numpy arrays
+    print(features_ppg_scaled[0:4])
+    features_ppg_scaled = np.array(features_ppg_scaled)
+    feature_acc = np.array(feature_acc)
+    t_unix_feat_total = np.array(t_unix_feat_total)
+
+    # Synchronization information
+    # TODO: store this, as this is needed for the HR pipeline
+    # v_sync_ppg_total = np.array([
+    #     ppg_indices[0],  # start index
+    #     ppg_indices[1],  # end index
+    #     segment_ppg[0],  # Segment index
+    #     count  # Number of epochs in the segment
+    # ])
+
+    metadata_features_ppg = metadata_samples_ppg.copy()
+    metadata_features_ppg.channels = ["variance", "mean", "median", "kurtosis", "skewness", "dominant_frequency", "relative_power", "spectral_entropy", "signal_noise_ratio", "second_highest_peak"]
+    metadata_features_acc = metadata_samples_acc.copy()
+    metadata_features_acc.channels = ["power_ratio"]
+    metadata_time_ppg = metadata_time_ppg.copy()
+    metadata_time_ppg.channels = ["time"]
+    metadata_time_acc = metadata_time_acc.copy()
+    metadata_time_acc.channels = ["time"]
+
+    write_data(metadata_time_ppg, metadata_features_ppg, output_path, 'features_ppg_meta.json', features_ppg_scaled)
+    write_data(metadata_time_acc, metadata_features_acc, output_path, 'feature_acc_meta.json', feature_acc)
+

paradigma/heart_rate_analysis_config.py

@@ -0,0 +1,9 @@
+
+
+
+class HeartRateFeatureExtractionConfig:
+
+    def __init__(self) -> None:
+        
+        self.sampling_frequency_imu = 100
+        self.sampling_frequency_ppg = 30

paradigma/heart_rate_util.py

@@ -0,0 +1,173 @@
+from typing import List, Tuple, Union
+import pickle
+import pandas as pd
+import numpy as np
+from scipy.signal import welch, find_peaks
+from scipy.stats import kurtosis, skew
+
+
+def extract_ppg_features(arr_ppg: np.ndarray, sampling_frequency: int) -> np.ndarray:
+    # Number of features
+    feature_count = 10
+    
+    # Initialize features array
+    features_ppg = np.zeros(feature_count)
+    
+    # Time-domain features
+    absPPG = np.abs(arr_ppg)
+    features_ppg[0] = np.var(arr_ppg)  # Feature 1: variance
+    features_ppg[1] = np.mean(absPPG)  # Feature 2: mean
+    features_ppg[2] = np.median(absPPG)  # Feature 3: median
+    features_ppg[3] = kurtosis(arr_ppg)  # Feature 4: kurtosis
+    features_ppg[4] = skew(arr_ppg)  # Feature 5: skewness
+    
+    window = 3 * sampling_frequency  # 90 samples for Welch's method => fr = 2/3 = 0.67 Hz --> not an issue with a clear distinct frequency
+    overlap = int(0.5 * window)  # 45 samples overlap for Welch's Method
+    
+    f, P = welch(arr_ppg, sampling_frequency, nperseg=window, noverlap=overlap)
+    
+    # Find the dominant frequency
+    maxIndex = np.argmax(P)
+    features_ppg[5] = f[maxIndex]  # Feature 6: dominant frequency
+    
+    # Find indices of f in relevant physiological heart range 45-180 bpm (0.75 - 3 Hz)
+    ph_idx = np.where((f >= 0.75) & (f <= 3))[0]
+    maxIndex_ph = np.argmax(P[ph_idx])
+    dominantFrequency_ph = f[ph_idx[maxIndex_ph]]
+    f_dom_band = np.where((f >= dominantFrequency_ph - 0.2) & (f <= dominantFrequency_ph + 0.2))[0]
+    features_ppg[6] = np.trapz(P[f_dom_band]) / np.trapz(P)  # Feature 7: relative power
+    
+    # Normalize the power spectrum
+    pxx_norm = P / np.sum(P)
+    
+    # Compute spectral entropy
+    features_ppg[7] = -np.sum(pxx_norm * np.log2(pxx_norm)) / np.log2(len(arr_ppg))  # Feature 8: spectral entropy
+    
+    # Signal to noise ratio
+    arr_signal = np.var(arr_ppg)
+    arr_noise = np.var(absPPG)
+    features_ppg[8] = arr_signal / arr_noise  # Feature 9: surrogate of signal to noise ratio
+    
+    # Autocorrelation features
+    ppg_series = pd.Series(arr_ppg)
+    autocorrelations = [ppg_series.autocorr(lag=i) for i in range(sampling_frequency*3)]
+    
+    # Finding peaks in autocorrelation
+    peaks, _ = peakdet(np.array(autocorrelations), delta=0.01)
+    sorted_peaks = np.sort(peaks)
+    #TODO: double check if this is correct
+    print(sorted_peaks)
+    
+    if len(sorted_peaks) > 1:
+        features_ppg[9] = sorted_peaks[1]  # Feature 10: the second highest peak
+    else:
+        features_ppg[9] = 0  # Set to 0 if there is no clear second peak
+    
+    return features_ppg
+
+# Example usage:
+# PPG = np.random.randn(300)  # Example PPG signal, replace with actual data
+# fs = 50  # Example sampling frequency, replace with actual sampling rate
+# features_df = ppg_features(PPG, fs)
+# print(features_df)
+
+
+def peakdet(v: np.ndarray, delta, x: Union[np.ndarray, None]=None) -> Tuple[List[Tuple[int, float]], List[Tuple[int, float]]]:
+    """
+    Detect peaks in a vector.
+    
+    Args:
+    v (numpy array): Input vector.
+    delta (float): Minimum difference between a peak and its surrounding values.
+    x (numpy array, optional): Indices corresponding to the values in v. If not provided, indices are generated.
+
+    Returns:
+    maxtab (list of tuples): Local maxima as (index, value) pairs.
+    mintab (list of tuples): Local minima as (index, value) pairs.
+    """
+    
+    if x is None:
+        x = np.arange(len(v))
+    else:
+        if len(v) != len(x):
+            raise ValueError("Input vectors v and x must have the same length")
+
+    # Detect maxima
+    max_indices, _ = find_peaks(v, height=delta)
+    maxtab = [(x[idx], v[idx]) for idx in max_indices]
+    
+    # Detect minima by inverting the signal
+    min_indices, _ = find_peaks(-v, height=delta)
+    mintab = [(x[idx], v[idx]) for idx in min_indices]
+    
+    return maxtab, mintab
+
+# Example usage:
+# v = [0, 1, 2, 1, 0, 1, 2, 3, 2, 1, 0]
+# delta = 1
+# maxtab, mintab = peakdet(v, delta)
+# print("Maxima:", maxtab)
+# print("Minima:", mintab)
+
+
+def calculate_power_ratio(f1: np.ndarray, PSD_acc: np.ndarray, f2: np.ndarray, PSD_ppg: np.ndarray) -> float:
+    """
+    Calculates the power ratio of the accelerometer signal in the PPG frequency range.
+    
+    Args:
+    f1 (numpy.ndarray): Frequency bins for the accelerometer signal.
+    PSD_acc (numpy.ndarray): Power Spectral Density of the accelerometer signal.
+    f2 (numpy.ndarray): Frequency bins for the PPG signal.
+    PSD_ppg (numpy.ndarray): Power Spectral Density of the PPG signal.
+    
+    Returns:
+    float: The power ratio of the accelerometer signal in the PPG frequency range.
+    """
+    
+    # Find the index of the maximum PSD value in the PPG signal
+    max_PPG_psd_idx = np.argmax(PSD_ppg)
+    max_PPG_freq_psd = f2[max_PPG_psd_idx]
+    
+    # Find the index of the closest frequency in the accelerometer signal to the dominant PPG frequency
+    corr_acc_psd_df_idx = np.argmin(np.abs(max_PPG_freq_psd - f1))
+    
+    df_idx = np.arange(corr_acc_psd_df_idx-1, corr_acc_psd_df_idx+2)
+    
+    # Find the index of the closest frequency in the accelerometer signal to the first harmonic of the PPG frequency
+    corr_acc_psd_fh_idx = np.argmin(np.abs(max_PPG_freq_psd*2 - f1))
+    fh_idx = np.arange(corr_acc_psd_fh_idx-1, corr_acc_psd_fh_idx+2)
+    
+    # Calculate the power ratio
+    acc_power_PPG_range = np.trapz(PSD_acc[df_idx], f1[df_idx]) + np.trapz(PSD_acc[fh_idx], f1[fh_idx])
+    acc_power_total = np.trapz(PSD_acc, f1)
+    
+    acc_power_ratio = acc_power_PPG_range / acc_power_total
+    
+    return acc_power_ratio
+
+# Example usage:
+# f1 = np.array([0.1, 0.2, 0.3, 0.4, 0.5])
+# PSD_acc = np.array([1, 2, 3, 2, 1])
+# f2 = np.array([0.1, 0.2, 0.3, 0.4, 0.5])
+# PSD_ppg = np.array([1, 3, 2, 1, 0.5])
+# result = acc_feature(f1, PSD_acc, f2, PSD_ppg)
+# print(result)
+
+def read_PPG_quality_classifier(classifier_path: str):
+    """
+    Read the PPG quality classifier from a file.
+
+    Parameters
+    ----------
+    classifier_path : str
+        The path to the classifier file.
+
+    Returns
+    -------
+    dict
+        The classifier dictionary.
+    """
+    with open(classifier_path, 'rb') as f:
+        clf = pickle.load(f)
+    return clf
+

paradigma/imu_preprocessing.py

@@ -0,0 +1,232 @@
+from pathlib import Path
+from typing import List, Union
+import numpy as np
+import pandas as pd
+from scipy import signal
+from scipy.interpolate import CubicSpline
+
+import tsdf
+from paradigma.constants import DataColumns, TimeUnit
+from paradigma.util import write_data, read_metadata
+from paradigma.preprocessing_config import IMUPreprocessingConfig
+
+
+def preprocess_imu_data(input_path: Union[str, Path], output_path: Union[str, Path], config: IMUPreprocessingConfig) -> None:
+
+    # Load data
+    metadata_time, metadata_samples = read_metadata(str(input_path), str(config.meta_filename),
+                                                    str(config.time_filename), str(config.values_filename))
+    df = tsdf.load_dataframe_from_binaries([metadata_time, metadata_samples], tsdf.constants.ConcatenationType.columns)
+
+    # Rename columns
+    df = df.rename(columns={f'rotation_{a}': f'gyroscope_{a}' for a in ['x', 'y', 'z']})
+    df = df.rename(columns={f'acceleration_{a}': f'accelerometer_{a}' for a in ['x', 'y', 'z']})
+
+    # convert to relative seconds from delta milliseconds
+    df[config.time_colname] = transform_time_array(
+        time_array=df[config.time_colname],
+        scale_factor=1000, 
+        input_unit_type = TimeUnit.DIFFERENCE_MS,
+        output_unit_type = TimeUnit.RELATIVE_MS)
+    
+
+    df = resample_data(
+        df=df,
+        time_column=config.time_colname,
+        time_unit_type=TimeUnit.RELATIVE_MS,
+        unscaled_column_names = list(config.d_channels_imu.keys()),
+        scale_factors=metadata_samples.scale_factors,
+        resampling_frequency=config.sampling_frequency)
+    
+    if config.side_watch == 'left':
+        df[DataColumns.ACCELEROMETER_X] *= -1
+
+    for col in config.d_channels_accelerometer.keys():
+
+        # change to correct units [g]
+        if config.acceleration_units == 'm/s^2':
+            df[col] /= 9.81
+
+        for result, side_pass in zip(['filt', 'grav'], ['hp', 'lp']):
+            df[f'{result}_{col}'] = butterworth_filter(
+                single_sensor_col=np.array(df[col]),
+                order=config.filter_order,
+                cutoff_frequency=config.lower_cutoff_frequency,
+                passband=side_pass,
+                sampling_frequency=config.sampling_frequency,
+                )
+            
+        df = df.drop(columns=[col])
+        df = df.rename(columns={f'filt_{col}': col})
+
+    # Store data
+    for sensor, units in zip(['accelerometer', 'gyroscope'], ['g', config.rotation_units]):
+        df_sensor = df[[config.time_colname] + [x for x in df.columns if sensor in x]]
+
+        metadata_samples.channels = [x for x in df.columns if sensor in x]
+        metadata_samples.units = list(np.repeat(units, len(metadata_samples.channels)))
+        metadata_samples.file_name = f'{sensor}_samples.bin'
+
+        metadata_time.file_name = f'{sensor}_time.bin'
+        metadata_time.units = ['time_relative_ms']
+
+        write_data(metadata_time, metadata_samples, output_path, f'{sensor}_meta.json', df_sensor)
+
+def transform_time_array(
+    time_array: pd.Series,
+    scale_factor: float,
+    input_unit_type: str,
+    output_unit_type: str,
+    start_time: float = 0.0,
+) -> np.ndarray:
+    """
+    Transforms the time array to relative time (when defined in delta time) and scales the values.
+
+    Parameters
+    ----------
+    time_array : pd.Series
+        The time array in milliseconds to transform.
+    scale_factor : float
+        The scale factor to apply to the time array.
+    input_unit_type : str
+        The time unit type of the input time array. Raw PPP data was in `TimeUnit.DIFFERENCE_MS`.
+    output_unit_type : str
+        The time unit type of the output time array. The processing is often done in `TimeUnit.RELATIVE_MS`.
+    start_time : float, optional
+        The start time of the time array in UNIX milliseconds (default is 0.0)
+
+    Returns
+    -------
+    time_array
+        The transformed time array in milliseconds, with the specified time unit type.
+    """
+    # Scale time array and transform to relative time (`TimeUnit.RELATIVE_MS`) 
+    if input_unit_type == TimeUnit.DIFFERENCE_MS:
+    # Convert a series of differences into cumulative sum to reconstruct original time series.
+        time_array = np.cumsum(np.double(time_array)) / scale_factor
+    elif input_unit_type == TimeUnit.ABSOLUTE_MS:
+        # Set the start time if not provided.
+        if np.isclose(start_time, 0.0, rtol=1e-09, atol=1e-09):
+            start_time = time_array[0]
+        # Convert absolute time stamps into a time series relative to start_time.
+        time_array = (time_array - start_time) / scale_factor
+    elif input_unit_type == TimeUnit.RELATIVE_MS:
+        # Scale the relative time series as per the scale_factor.
+        time_array = time_array / scale_factor
+
+    # Transform the time array from `TimeUnit.RELATIVE_MS` to the specified time unit type
+    if output_unit_type == TimeUnit.ABSOLUTE_MS:
+        # Converts time array to absolute time by adding the start time to each element.
+        time_array = time_array + start_time
+    elif output_unit_type == TimeUnit.DIFFERENCE_MS:
+        # Creates a new array starting with 0, followed by the differences between consecutive elements.
+        time_array = np.diff(np.insert(time_array, 0, start_time))
+    elif output_unit_type == TimeUnit.RELATIVE_MS:
+        # The array is already in relative format, do nothing.
+        pass
+    return time_array
+
+
+def resample_data(
+    df: pd.DataFrame,
+    time_column : str,
+    time_unit_type: str,
+    unscaled_column_names: List[str],
+    resampling_frequency: int,
+    scale_factors: List[float] = [],
+    start_time: float = 0.0,
+) -> pd.DataFrame:
+    """
+    Resamples the IMU data to the resampling frequency. The data is scaled before resampling.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The data to resample.
+    time_column : str
+        The name of the time column.
+    time_unit_type : str
+        The time unit type of the time array. The method currently works only for `TimeUnit.RELATIVE_MS`.
+    unscaled_column_names : List[str]
+        The names of the columns to resample.
+    resampling_frequency : int
+        The frequency to resample the data to.
+    scale_factors : list, optional
+        The scale factors to apply to the values before resampling (default is []).
+    start_time : float, optional
+        The start time of the time array, which is required if it is in absolute format (default is 0.0).
+
+    Returns
+    -------
+    pd.DataFrame
+        The resampled data.
+    """
+    # We need a start_time if the time is in absolute time format
+    if time_unit_type == TimeUnit.ABSOLUTE_MS and start_time == 0.0:
+        raise ValueError("start_time is required for absolute time format")
+
+    # get time and values
+    time_abs_array=np.array(df[time_column])
+    values_unscaled=np.array(df[unscaled_column_names])
+
+    # scale data
+    if len(scale_factors) != 0 and scale_factors is not None:
+        scaled_values = values_unscaled * scale_factors
+
+    # resample
+    t_resampled = np.arange(start_time, time_abs_array[-1], 1 / resampling_frequency)
+
+    # create dataframe
+    df = pd.DataFrame(t_resampled, columns=[time_column])
+
+    # interpolate IMU - maybe a separate method?
+    for j, sensor_col in enumerate(unscaled_column_names):
+        if not np.all(np.diff(time_abs_array) > 0):
+            raise ValueError("time_abs_array is not strictly increasing")
+
+        cs = CubicSpline(time_abs_array, scaled_values.T[j])
+        #TODO: isn't sensor_col of type DataColumns?
+        df[sensor_col] = cs(df[time_column])
+
+    return df
+
+
+def butterworth_filter(
+    single_sensor_col: np.ndarray,
+    order: int,
+    cutoff_frequency: Union[float, List[float]],
+    passband: str,
+    sampling_frequency: int,
+):
+    """
+    Applies the Butterworth filter to a single sensor column
+
+    Parameters
+    ----------
+    single_sensor_column: pd.Series
+        A single column containing sensor data in float format
+    order: int
+        The exponential order of the filter
+    cutoff_frequency: float or List[float]
+        The frequency at which the gain drops to 1/sqrt(2) that of the passband. If passband is 'band', then cutoff_frequency should be a list of two floats.
+    passband: str
+        Type of passband: ['hp', 'lp' or 'band']
+    sampling_frequency: int
+        The sampling frequency of the sensor data
+
+    Returns
+    -------
+    sensor_column_filtered: pd.Series
+        The origin sensor column filtered applying a Butterworth filter
+    """
+
+    sos = signal.butter(
+        N=order,
+        Wn=cutoff_frequency,
+        btype=passband,
+        analog=False,
+        fs=sampling_frequency,
+        output="sos",
+    )
+    return signal.sosfiltfilt(sos, single_sensor_col)
+    

paradigma/ppg/feat_extraction/acc_feature.m

@@ -0,0 +1,20 @@
+function acc_power_ratio = acc_feature(f1, PSD_acc, f2, PSD_ppg)
+    % This function calculates the power ratio of the accelerometer signal in the PPG frequency range.
+    % The power ratio is defined as the ratio of the power in the PPG frequency range to the total power.
+    [~, max_PPG_psd_idx] = max(PSD_ppg);
+    max_PPG_freq_psd = f2(max_PPG_psd_idx);
+    
+    %%---check dominant frequency (df) indices----%%
+    [~, corr_acc_psd_df_idx] = min(abs(max_PPG_freq_psd-f1)); 
+    
+    df_idx = corr_acc_psd_df_idx-1:corr_acc_psd_df_idx+1;
+    
+    %%---check first harmonic (fh) frequency indices----%%
+    [~, corr_acc_psd_fh_idx] = min(abs(max_PPG_freq_psd*2-f1)); 
+    fh_idx = corr_acc_psd_fh_idx-1:corr_acc_psd_fh_idx+1;
+    
+    %%---calculate power ratio---%%
+    acc_power_PPG_range = trapz(f1(df_idx), PSD_acc(df_idx)) + trapz(f1(fh_idx), PSD_acc(fh_idx));
+    acc_power_total = trapz(f1, PSD_acc);
+    
+    acc_power_ratio = acc_power_PPG_range/acc_power_total;

paradigma/ppg/feat_extraction/peakdet.m

@@ -0,0 +1,64 @@
+function [maxtab, mintab]=peakdet(v, delta, x)
+%PEAKDET Detect peaks in a vector
+%        [MAXTAB, MINTAB] = PEAKDET(V, DELTA) finds the local
+%        maxima and minima ("peaks") in the vector V.
+%        MAXTAB and MINTAB consists of two columns. Column 1
+%        contains indices in V, and column 2 the found values.
+%      
+%        With [MAXTAB, MINTAB] = PEAKDET(V, DELTA, X) the indices
+%        in MAXTAB and MINTAB are replaced with the corresponding
+%        X-values.
+%
+%        A point is considered a maximum peak if it has the maximal
+%        value, and was preceded (to the left) by a value lower by
+%        DELTA.
+
+% Eli Billauer, 3.4.05
+% This function is released to the public domain; Any use is allowed.
+
+maxtab = [];
+mintab = [];
+
+v = v(:); % Just in case this wasn't a proper vector
+
+if nargin < 3
+  x = (1:length(v))';
+else
+  x = x(:);
+  if length(v)~= length(x)
+    error('Input vectors v and x must have same length');
+  end
+end
+
+if (length(delta(:)))>1
+  error('Input argument DELTA must be a scalar');
+end
+
+if delta <= 0
+  error('Input argument DELTA must be positive');
+end
+
+mn = Inf; mx = -Inf;
+mnpos = NaN; mxpos = NaN;
+
+lookformax = 1;
+
+for i=1:length(v)
+  this = v(i);
+  if this > mx, mx = this; mxpos = x(i); end
+  if this < mn, mn = this; mnpos = x(i); end
+
+  if lookformax
+    if this < mx-delta
+      maxtab = [maxtab ; mxpos mx];
+      mn = this; mnpos = x(i);
+      lookformax = 0;
+    end
+  else
+    if this > mn+delta
+      mintab = [mintab ; mnpos mn];
+      mx = this; mxpos = x(i);
+      lookformax = 1;
+    end
+  end
+end

paradigma/ppg/feat_extraction/ppg_features.m

@@ -0,0 +1,53 @@
+function [FeaturesPPG] = ppg_features(PPG,fs)
+    % extract features from the PPG signal, per 6sec window (PPG input is a 6sec window of PPG signal)
+    N_feat = 10;
+    FeaturesPPG = zeros(1, N_feat);
+    % Time-domain features
+    absPPG = abs(PPG);
+    FeaturesPPG(1) = var(PPG); % Feature 1: variance
+    FeaturesPPG(2) = mean(absPPG); % Feature 2: mean
+    FeaturesPPG(3) = median(absPPG); % Feature 3: median
+    FeaturesPPG(4) = kurtosis(PPG); % Feature 4: kurtosis
+    FeaturesPPG(5) = skewness(PPG); % Feature 5: skewness
+    
+    window = 3*fs;   % 90 samples for Welch's method => fr = 2/3 = 0.67 Hz --> not an issue with a clear distinct frequency
+    overlap = 0.5*window; % 45 samples overlap for Welch's Method
+    
+    [P, f] = pwelch(PPG, window, overlap, [], fs);
+    
+    % Find the dominant frequency
+    [~, maxIndex] = max(P);
+    FeaturesPPG(6) = f(maxIndex);    % Feature 6: dominant frequency
+    
+    ph_idx = find(f >= 0.75 & f <= 3); % find indices of f in relevant physiological heart range 45-180 bpm
+    [~, maxIndex_ph] = max(P(ph_idx)); %  Index of dominant frequency
+    dominantFrequency_ph = f(ph_idx(maxIndex_ph)); % Extract dominant frequency 
+    f_dom_band = find(f >= dominantFrequency_ph - 0.2 & f <= dominantFrequency_ph + 0.2); %
+    FeaturesPPG(7) = trapz(P(f_dom_band))/trapz(P);  % Feature 7 = relative power
+    
+    
+    % Normalize the power spectrum
+    pxx_norm = P / sum(P);
+    
+    % Compute spectral entropy
+    FeaturesPPG(8) = -sum(pxx_norm .* log2(pxx_norm))/log2(length(PPG)); % Feature 8 = spectral entropy --> normalize between 0 and 1! Or should we perform this operation at the min-max normalization! No because the values can come from different lengths!
+    
+    % Signal to noise ratio
+    Signal = var(PPG);
+    Noise = var(absPPG);
+    FeaturesPPG(9) = Signal/Noise; % Feature 9 = surrogate of signal to noise ratio
+    
+    %% Autocorrelation features
+    
+    [acf, ~] = autocorr(PPG, 'NumLags', fs*3); % Compute the autocorrelation of the PPG signal with a maximum lag of 3 seconds (or 3 time the sampling rate)
+    [peakValues, ~] = peakdet(acf, 0.01);
+    sortedValues = sort(peakValues(:,2), 'descend');     % sort the peaks found in the corellogram
+    if length(sortedValues) > 1
+        FeaturesPPG(10) = sortedValues(2); % determine the second peak as the highest peak after the peak at lag=0, the idea is to determine the periodicity of the signal
+    else
+        FeaturesPPG(10) = 0;              % Set at 0 if there is no clear second peak
+    end
+    
+    
+    
+