gaitsetpy.features.utils

  1import numpy as np
  2from scipy.stats import skew, kurtosis, entropy
  3from scipy.signal import welch, find_peaks
  4from scipy.fft import fft
  5from statsmodels.tsa.ar_model import AutoReg
  6
  7
  8def calculate_stride_times(signal, fs):
  9    """
 10    Calculate stride times from a signal using peak detection.
 11    Args:
 12        signal (np.array): Input signal.
 13        fs (int): Sampling frequency.
 14    Returns:
 15        avg_stride_time (float): Average stride time.
 16    """
 17    peaks, _ = find_peaks(signal)
 18    stride_times = np.diff(peaks) / fs
 19    avg_stride_time = np.mean(stride_times) if len(stride_times) > 0 else 0
 20    return avg_stride_time
 21
 22def calculate_zero_crossing_rate(signal):
 23    """
 24    Calculate the zero-crossing rate of a signal.
 25    Args:
 26        signal (np.array): Input signal.
 27    Returns:
 28        zcr (float): Zero-crossing rate.
 29    """
 30    n = len(signal)
 31    zcr = 1 / (n - 1) * sum(0.5 * abs(np.sign(signal[i + 1]) - np.sign(signal[i])) for i in range(n - 1))
 32    return zcr
 33
 34def calculate_power(signal, fs, band):
 35    """
 36    Calculate the power of a signal in a specific frequency band.
 37    Args:
 38        signal (np.array): Input signal.
 39        fs (int): Sampling frequency.
 40        band (tuple): Frequency band (low, high).
 41    Returns:
 42        band_power (float): Power in the specified frequency band.
 43    """
 44    # f, Pxx = welch(signal, fs=fs, nperseg=min(len(signal), 1024))
 45    f, Pxx = welch(signal, fs=fs, nperseg = min(len(signal), 192))  # Ensure nperseg ≤ length)
 46    band_power = np.trapz(Pxx[(f >= band[0]) & (f <= band[1])], f[(f >= band[0]) & (f <= band[1])])
 47    return band_power
 48
 49def calculate_freezing_index(signal, fs):
 50    """
 51    Calculate the freezing index of a signal.
 52    Args:
 53        signal (np.array): Input signal.
 54        fs (int): Sampling frequency.
 55    Returns:
 56        freezing_index (float): Freezing index.
 57    """
 58    power_3_8 = calculate_power(signal, fs, (3, 8))
 59    power_0_5_3 = calculate_power(signal, fs, (0.5, 3))
 60    freezing_index = power_3_8 / power_0_5_3 if power_0_5_3 != 0 else 0
 61    return freezing_index
 62
 63def calculate_standard_deviation(signal):
 64    """
 65    Calculate the standard deviation of a signal.
 66    Args:
 67        signal (np.array): Input signal.
 68    Returns:
 69        std_dev (float): Standard deviation.
 70    """
 71    return np.std(signal)
 72
 73def calculate_entropy(signal):
 74    """
 75    Calculate the entropy of a signal.
 76    Args:
 77        signal (np.array): Input signal.
 78    Returns:
 79        entropy_value (float): Entropy.
 80    """
 81    value, counts = np.unique(signal, return_counts=True)
 82    probabilities = counts / len(signal)
 83    return entropy(probabilities, base=2)
 84
 85def calculate_energy(signal):
 86    """
 87    Calculate the energy of a signal.
 88    Args:
 89        signal (np.array): Input signal.
 90    Returns:
 91        energy (float): Energy.
 92    """
 93    return np.sum(signal ** 2)
 94
 95def calculate_variance(signal):
 96    """
 97    Calculate the variance of a signal.
 98    Args:
 99        signal (np.array): Input signal.
100    Returns:
101        variance (float): Variance.
102    """
103    return np.var(signal)
104
105def calculate_kurtosis(signal):
106    """
107    Calculate the kurtosis of a signal.
108    Args:
109        signal (np.array): Input signal.
110    Returns:
111        kurtosis_value (float): Kurtosis.
112    """
113    try:
114        return kurtosis(signal, fisher=False)
115    except Exception as e:
116        print(f"An error occurred in feature 'kurtosis': {e}")
117        return 0
118
119def calculate_step_time(signal, fs):
120    """
121    Calculate step times from a signal using peak detection.
122    Args:
123        signal (np.array): Input signal.
124        fs (int): Sampling frequency.
125    Returns:
126        step_times (np.array): Array of step times.
127    """
128    peaks, _ = find_peaks(signal)
129    step_times = np.diff(peaks) / fs
130    return step_times
131
132def calculate_mean(signal):
133    """Calculate the mean of the signal."""
134    return np.mean(signal)
135
136def calculate_max(signal):
137    """Calculate the maximum value of the signal."""
138    return np.max(signal)
139
140def calculate_min(signal):
141    """Calculate the minimum value of the signal."""
142    return np.min(signal)
143
144def calculate_median(signal):
145    """Calculate the median of the signal."""
146    return np.median(signal)
147
148def calculate_skewness(signal):
149    """Calculate the skewness of the signal."""
150    try:
151        return skew(signal)
152    except Exception as e:
153        print(f"An error occurred in skewness: {e}")
154        return 0
155
156def calculate_root_mean_square(signal):
157    """Calculate the root mean square of the signal."""
158    return np.sqrt(np.mean(np.square(signal)))
159
160def calculate_range(signal):
161    """Calculate the range of the signal."""
162    return np.max(signal) - np.min(signal)
163
164def calculate_correlation(signal1, signal2):
165    """Calculate the correlation between two signals."""
166    return np.corrcoef(signal1, signal2)[0, 1]
167
168def calculate_dominant_frequency(signal, fs):
169    """Calculate the dominant frequency of the signal."""
170    try:
171        fft_values = np.abs(fft(signal))
172        freqs = np.fft.fftfreq(len(signal), 1 / fs)
173        dominant_freq = freqs[np.argmax(fft_values)]
174        return dominant_freq
175    except Exception as e:
176        print(f"An error occurred: {e}")
177        return 0
178
179def calculate_peak_height(signal):
180    """Calculate the peak height of the signal."""
181    peaks, _ = find_peaks(signal)
182    return np.max(signal[peaks]) if len(peaks) > 0 else 0
183
184def calculate_interquartile_range(signal):
185    """Calculate the interquartile range of the signal."""
186    try:
187        q75, q25 = np.percentile(signal, [75, 25])
188        return q75 - q25
189    except Exception as e:
190        print(f"An error occurred in feature 'interquartile_range': {e}")
191        return 0
192
193def calculate_mode(signal):
194    """Calculate the mode of the signal."""
195    values, counts = np.unique(signal, return_counts=True)
196    return values[np.argmax(counts)]
197
198def calculate_cadence(signal, fs):
199    """Calculate the cadence (steps per minute) of the signal."""
200    peaks, _ = find_peaks(signal)
201    step_count = len(peaks)
202    duration = len(signal) / fs
203    return (step_count / duration) * 60
204
205def calculate_mean_absolute_value(signal):
206    """Calculate the mean absolute value of the signal."""
207    return np.mean(np.abs(signal))
208
209def calculate_median_absolute_deviation(signal):
210    """Calculate the median absolute deviation of the signal."""
211    return np.median(np.abs(signal - np.median(signal)))
212
213def calculate_peak_frequency(signal, fs):
214    """Calculate the peak frequency of the signal."""
215    try:
216        f, Pxx = welch(signal, fs=fs, nperseg=min(len(signal), 192))  # Ensure nperseg ≤ length
217        return f[np.argmax(Pxx)]
218    except Exception as e:
219        print(f"An error occurred in feature 'peak_frequency': {e}")
220        return 0
221
222def calculate_peak_width(signal, fs):
223    """Calculate the peak width of the signal."""
224    peaks, _ = find_peaks(signal)
225    if len(peaks) == 0:
226        return 0
227    peak_heights = signal[peaks]
228    half_max = np.max(peak_heights) / 2
229    widths = np.diff(np.where(signal > half_max)[0])
230    return np.mean(widths) / fs if len(widths) > 0 else 0
231
232def calculate_power_spectral_entropy(signal, fs):
233    """Calculate the power spectral entropy of the signal."""
234    try:
235        f, Pxx = welch(signal, fs=fs, nperseg=min(len(signal), 192))  # Ensure nperseg ≤ length
236        Pxx_norm = Pxx / np.sum(Pxx)
237        return -np.sum(Pxx_norm * np.log2(Pxx_norm + np.finfo(float).eps))
238    except Exception as e:
239        print(f"An error occurred in feature 'power spectral entropy': {e}")
240        return 0
241
242def calculate_principal_harmonic_frequency(signal, fs):
243    """Calculate the principal harmonic frequency of the signal."""
244    try:
245        fft_values = np.abs(fft(signal))
246        freqs = np.fft.fftfreq(len(signal), 1 / fs)
247        return freqs[np.argmax(fft_values)]
248    except Exception as e:
249        print(f"An error occurred in feature 'principal_harmonic_frequency': {e}")
250        return 0
251
252def calculate_auto_regression_coefficients(signal, order=3):
253    """Calculate the auto-regression coefficients of the signal."""
254    try:
255        model = AutoReg(signal, lags=order)
256        results = model.fit()
257        return results.params
258    except Exception as e:
259        print(f"An error occurred in feature 'auto_regression_coefficients': {e}")
260        return 0