Heart rate estimation #85

KarsVeldkamp · 2024-12-11T11:33:18Z

Ha Erik,

Hierbij de PR voor HR estimation. Er zitten ook een paar renaming dingen in voor de preprocessing maar die spreken denk ik voor zich. Ga ik hierna mij focussen op efficiëntie ;).

… into heart_rate_estimation

…tead of imu

Erikpostt · 2024-12-12T08:24:19Z

docs/notebooks/ppg/ppg_analysis.ipynb

+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of the original data: (64775, 2) (72947, 4)\n",
+      "Shape of the overlapping segments: (64775, 2) (64361, 4)\n"
+     ]
+    }
+   ],


Je hebt hier en daar nog execution counts, wat op zich niet een probleem is omdat je misschien juist deze output wilt laten zien aan een gebruiker zonder dat een gebruiker de code hoeft te draaien. Even een check of dat je intentie was.

Ehm uiteindelijk wel, maar niet voor nu eig dus excuses

Erikpostt · 2024-12-12T08:24:54Z

docs/notebooks/ppg/ppg_analysis.ipynb

   "source": [
    "ppg_config = PPGConfig()\n",
    "imu_config = IMUConfig()\n",
    "metadatas_ppg, metadatas_imu = scan_and_sync_segments(os.path.join(path_to_sensor_data, 'ppg'),\n",
    "                                                       os.path.join(path_to_sensor_data, 'imu'))\n",
-    "df_ppg_proc, df_imu_proc=preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",
+    "df_ppg_proc, df_acc_proc=preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",


Suggested change

"df_ppg_proc, df_acc_proc=preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",

"df_ppg_proc, df_acc_proc = preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",

Erikpostt · 2024-12-12T08:27:58Z

src/paradigma/config.py

-        self.window_step_size_s: int = 1
-        self.min_hr_samples = min_window_length * self.sampling_frequency
+        self.window_overlap_s = self.window_length_s - self.window_step_size_s
+        self.min_hr_samples = int(min_window_length * self.sampling_frequency)


E.g., if sampling frequency equals 25 Hz, and window length equals 3.5, then we have min_window_length * self.sampling_frequency equals 25 * 3.5 = 87.5. Now, inconveniently int(87.5) equals 87 (int rounds to the lowest integer). So perhaps, for these edge cases, you want to use int(np.round(min_window_length * self.sampling_frequency)) or something along these lines.

Goed punt! En zal het aanpassen, heb je bezwaren tegen round i.p.v. np.round omdat je anders in de config numpy moet inladen als module @Erikpostt

There are some minor differences between the two methods, and I don't think that having to import numpy should restrict us to using round(). I'll let you decide on this matter.

ALlright, but it doesn't seem that np.round is preferred over round() right? So than we can use just round() @Erikpostt

No they seem to have different methods for rounding, but I expect that, in case the rounding is ever done differently, it should not affect the results much.

Erikpostt · 2024-12-12T08:30:30Z

src/paradigma/heart_rate/heart_rate_analysis.py

+
+
+def estimate_heart_rate(df: pd.DataFrame, df_ppg_preprocessed: pd.DataFrame, config:HeartRateExtractionConfig) -> pd.DataFrame:  


To me it's a little ambiguous as to the meaning of df. Could you perhaps choose a different naming for df, and expand on the difference between these two dataframes in the docstrings?

Erikpostt · 2024-12-12T08:30:41Z

src/paradigma/heart_rate/heart_rate_analysis.py

+
+
+def estimate_heart_rate(df: pd.DataFrame, df_ppg_preprocessed: pd.DataFrame, config:HeartRateExtractionConfig) -> pd.DataFrame:  


Suggested change

def estimate_heart_rate(df: pd.DataFrame, df_ppg_preprocessed: pd.DataFrame, config:HeartRateExtractionConfig) -> pd.DataFrame:

def estimate_heart_rate(df: pd.DataFrame, df_ppg_preprocessed: pd.DataFrame, config: HeartRateExtractionConfig) -> pd.DataFrame:

Erikpostt · 2024-12-12T08:31:21Z

src/paradigma/heart_rate/heart_rate_analysis.py

+    # Assign window-level probabilities to individual samples
+    ppg_post_prob = df.loc[:, DataColumns.PRED_SQA_PROBA].to_numpy()
+    #acc_label = df.loc[:, DataColumns.ACCELEROMETER_LABEL].to_numpy() # Adjust later in data columns to get the correct label, should be first intergrated in feature extraction and classification


Is this intentional?

bedoel je dat de acc_label uitgecomment is? Want dat is intentional nu ja @Erikpostt

Yes, I was just wondering.

Erikpostt · 2024-12-12T08:32:35Z

src/paradigma/heart_rate/heart_rate_analysis.py

Perhaps add brief comments (#) here to explain what happens, e.g., # Add signal quality value to each window and # Extract HR segments above signal quality threshold.

src/paradigma/heart_rate/heart_rate_analysis.py

Erikpostt · 2024-12-12T08:34:15Z

src/paradigma/heart_rate/heart_rate_analysis.py

+
+        # Generate HR estimation time array
+        rel_segment_time = df_ppg_preprocessed.time[start_idx:end_idx].values


Is .time the same as [DataColumns.TIME]?

nee, goed punt

Erikpostt · 2024-12-12T08:35:22Z

src/paradigma/heart_rate/heart_rate_analysis.py

+        rel_segment_time = df_ppg_preprocessed.time[start_idx:end_idx].values
+        n_full_segments = len(rel_segment_time) // config.hr_est_samples
+        hr_time = rel_segment_time[:n_full_segments * config.hr_est_samples : config.hr_est_samples] # relative time in seconds after the start of the segment


Perhaps you could clarify this process a little using comments (#), I'm not sure I understand it as it is now.

Erikpostt · 2024-12-12T08:37:02Z

src/paradigma/heart_rate/heart_rate_analysis_config.py

Why did you create this config again? Is it necessary for your code to run? Or is this your way of showing you disagree with the current format? ;)

Om jou te pesten, nee zonder gekheid ik had hem nog nodig om de config.py aan te passen omdat hij in de vorige merge was verwijderd. Echter had ik hem al gecommit naar deze branch voordat we de configs gingen omschrijven dus daardoor is hij uit het oog verloren. Zal hem verwijderen @Erikpostt

Erikpostt · 2024-12-12T08:37:48Z

src/paradigma/heart_rate/heart_rate_estimation.py

+from paradigma.config import HeartRateExtractionConfig
+from paradigma.heart_rate.tfd import nonsep_gdtfd
+
+def assign_sqa_label(ppg_prob, config: HeartRateExtractionConfig, acc_label=None) -> np.ndarray:


Suggested change

def assign_sqa_label(ppg_prob, config: HeartRateExtractionConfig, acc_label=None) -> np.ndarray:

def assign_sqa_label(ppg_prob: np.ndarray, config: HeartRateExtractionConfig, acc_label: np.ndarray=None) -> np.ndarray:

Erikpostt · 2024-12-12T08:38:07Z

src/paradigma/heart_rate/heart_rate_estimation.py

+    Parameters:
+    - ppg_prob: numpy array of probabilities for PPG
+    - acc_label: numpy array of labels for accelerometer (optional)
+    - fs: Sampling frequency


I think these need to be updated.

Erikpostt · 2024-12-12T08:39:37Z

src/paradigma/heart_rate/heart_rate_estimation.py

+
+    # Calculate number of samples to shift for each epoch
+    samples_shift = config.window_step_size_s * fs
+    n_samples = int((len(ppg_prob) + config.window_overlap_s) * fs)


Same to a comment I made earlier, perhaps you first want to round before converting to an integer to avoid 8.6 being rounded to 8.

Erikpostt · 2024-12-12T08:40:06Z

src/paradigma/heart_rate/heart_rate_estimation.py

+        start_idx = int(np.floor((i - (samples_per_epoch - samples_shift)) / fs))
+        end_idx = int(np.floor(i / fs))


I believe int already does np.floor inherently, but you could check.

Not for negative numbers, and that's what I need, so I will update it to integer division because that's probably the most efficient

Could i - (samples_per_epoch - samples_shift) be negative? Smart thinking though about the np.floor for negative values.

Yes it is for the edge cases at the start where i = 1:150 (because samples_per_epoch is 180 and samples_shift is 30)

Erikpostt · 2024-12-12T08:41:00Z

src/paradigma/heart_rate/heart_rate_estimation.py

+        if start_idx < 0:
+            start_idx = 0


Perhaps, instead of this, you could change the earlier:

start_idx = int(np.floor((i - (samples_per_epoch - samples_shift)) / fs))

to:

start_idx = max(0, int((i - (samples_per_epoch - samples_shift)) / fs))

Erikpostt · 2024-12-12T08:41:23Z

src/paradigma/heart_rate/heart_rate_estimation.py

+        if end_idx > len(ppg_prob):
+            end_idx = len(ppg_prob)


Similar approach could be used here.

Erikpostt · 2024-12-12T08:41:45Z

src/paradigma/heart_rate/heart_rate_estimation.py

+
+        # Calculate mean probability and majority voting for labels
+        data_prob[i] = np.mean(prob)
+        data_label_imu[i] = int(np.mean(label_imu) >= 0.5)


Use round here as well if appropriate.

In this case not, since it is a true false statement which I want to convert to 0 or 1, therefore this doesn't have to be rounded

Haha you're right, not sure where this suggestion came from. You might want to store it as boolean if TSDF allows (don't think it does yet though ...)

Erikpostt · 2024-12-12T08:42:56Z

src/paradigma/heart_rate/heart_rate_estimation.py

+
+    # Set probability to zero if majority IMU label is 0
+    data_prob[data_label_imu == 0] = 0
+    sqa_label = (data_prob > config.threshold_sqa).astype(np.int8)


Two questions:

Should the probability be (1) larger than, or (2) larger than or equal to?

Why do you convert it to np.int8? Why don't you store it as a boolean?

Probability is larger than (1) instead of (2) in my Matlab code, however this is not entirely correct so I would want to have (2) so I adjust it here. I won't expect that this really matters for the results because I won't expect that many probabilities to be exactly the threshold

I'll update this and store it as a boolean

Great! You might run into issues with storing as boolean due to TSDF constraints. I'm sorry if I got your hopes up.

This step doesn't have to be stored in tsdf luckily :). It's just an input for extracting the ppg segments suited for HR estimation

Erikpostt · 2024-12-12T08:44:30Z

src/paradigma/heart_rate/heart_rate_estimation.py

+        Length of each segment (in seconds) to calculate the time-frequency distribution.
+    fs : int
+        The sampling frequency of the PPG signal.
+    MA : int


I think you don't use this one anymore.

Erikpostt · 2024-12-12T08:46:14Z

src/paradigma/heart_rate/heart_rate_estimation.py

+    """
+
+    # Constants to handle boundary effects
+    edge_padding = 4  # Additional 4 seconds (2 seconds on both sides)


I'd suggest assigning edge_padding = 4 * fs and tfd_length = tfd_length * fs, since you use edge_padding and tfd_length only in combination with fs in this function, right?

Erikpostt · 2024-12-12T08:46:35Z

src/paradigma/heart_rate/heart_rate_estimation.py

+    original_segment_length = (len(ppg) - edge_padding * fs) / fs
+
+    # Determine the number of tfd_length-second segments
+    if original_segment_length > extended_epoch_length:


Larger, or larger or equal to?

Erikpostt · 2024-12-12T08:47:36Z

src/paradigma/heart_rate/heart_rate_estimation.py

+
+    Returns
+    -------
+    hr_smooth_tfd : list


np.array or np.ndarray now I believe.

Erikpostt · 2024-12-12T09:00:49Z

src/paradigma/heart_rate/tfd.py

+
+"""	
+
+def nonsep_gdtfd(x, kern_type=None, kern_params=None):


We have used Union so far, but apparently the correct way since Python 3.10 is using Pipe:

Suggested change

def nonsep_gdtfd(x, kern_type=None, kern_params=None):

def nonsep_gdtfd(

x: np.ndarray,

kern_type: None | str = None,

kern_params: None | dict = None

):

Erikpostt · 2024-12-12T09:03:22Z

src/paradigma/heart_rate/tfd.py

+    x_fft = np.fft.fft(x)
+
+    # Generate the analytic signal in the frequency domain
+    H = [1] + list(np.repeat(2, N-1)) + [1] + list(np.repeat(0, N-1))


Perhaps you could use np.concatenate here, which works for more than 2 items as well:

# Define three arrays arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) arr3 = np.array([7, 8, 9]) # Concatenate along the first axis (default) result = np.concatenate((arr1, arr2, arr3)) print(result) # Output: [1 2 3 4 5 6 7 8 9]

Or for lists:

# Define three lists list1 = [1, 2, 3] list2 = [4, 5, 6] list3 = [7, 8, 9] # Concatenate lists with NumPy result = np.concatenate((list1, list2, list3)) print(result) # Output: [1 2 3 4 5 6 7 8 9]

I suppose that the FFT works faster with two numpy arrays, but not sure.

Erikpostt · 2024-12-12T09:04:30Z

src/paradigma/heart_rate/tfd.py

+
+    return z
+
+def gen_time_lag(z):


Suggested change

def gen_time_lag(z):

def gen_time_lag(z: np.ndarray): -> np.ndarray

Erikpostt · 2024-12-12T09:05:27Z

src/paradigma/heart_rate/tfd.py

+
+    return tfd
+
+def multiply_kernel_signal(tfd, kern_type, kern_params, N, Nh):


Suggested change

def multiply_kernel_signal(tfd, kern_type, kern_params, N, Nh):

def multiply_kernel_signal(

tfd: np.ndarray,

kern_type: str,

kern_params: dict,

N: int,

Nh: int

) -> np.ndarray:

Erikpostt · 2024-12-12T09:05:50Z

src/paradigma/heart_rate/tfd.py

+        g_lag_slice = gen_doppler_lag_kern(kern_type, kern_params, N, m)
+
+        # Extract and transform the TFD slice for this lag
+        tfd_slice = np.fft.fft(tfd[:, m]) + 1j * np.fft.fft(tfd[:, Nh + m])


Suggested change

tfd_slice = np.fft.fft(tfd[:, m]) + 1j * np.fft.fft(tfd[:, Nh + m])

tfd_slice = np.fft.fft(tfd[:, m]) + j * np.fft.fft(tfd[:, Nh + m])

Erikpostt · 2024-12-12T09:06:12Z

src/paradigma/heart_rate/tfd.py

+
+    return tfd
+
+def gen_doppler_lag_kern(kern_type, kern_params, N, lag_index):


Also fix parameter types in your other functions.

Erikpostt · 2024-12-12T09:15:24Z

src/paradigma/heart_rate/tfd.py

+    elif kern_type == 'swvd':
+        key = 'lag'  # Key for the lag-independent kernel
+        # Smoothed Wigner-Ville Distribution (Lag Independent kernel)
+        if l < 2:
+            raise ValueError("Need at least two window parameters for SWVD")
+        win_length = kern_params['win_length']
+        win_type = kern_params['win_type']
+        win_param = kern_params['win_param'] if l >= 3 else 0
+        win_param2 = kern_params['win_param2'] if l >= 4 else 1
+
+        G1 = get_window(win_length, win_type, win_param)
+        G1 = pad_window(G1, N)
+
+        # Define window in the time domain or Doppler domain
+        if win_param2 == 0:
+            G1 = np.fft.fft(G1)
+            G1 /= G1[0]
+
+        g[:] = G1 # Assign the window to the kernel
+
+    elif kern_type == 'pwvd':
+        key = 'doppler'
+        # Pseudo-Wigner-Ville Distribution (Doppler Independent kernel)
+        if l < 2:
+            raise ValueError("Need at least two window parameters for PWVD") 
+        win_length = kern_params['win_length']
+        win_type = kern_params['win_type']
+        win_param = kern_params['win_param'] if l >= 3 else 0
+        win_param2 = kern_params['win_param2'] if l >= 4 else 0
+
+        G2 = get_window(win_length, win_type, win_param) # Generate the window, same per lag iteration
+        G2 = pad_window(G2, N)      # Zero-pad the window to the length of the signal
+        G2 = G2[lag_index]          # Extract the lag_index-th element of the window --> can this be done more efficiently? Since we only need one element of the window and the padding is similar for every iteration
+
+        g[:] = G2 # Assign the window to the kernel


I think you could combine these:

First:

if kern_type not in [X, Y, Z, A, B, C]: raise("You should pick one of ...")

Note: you can also use it at the end like you've used it in the else statement. I only saw this later.

Then

if kern_type == 'wvd': ...

elif kern_type == 'sep': ....

else: if l < 2: raise ValueError("Need at least two window parameters for {kern_type.upper()}") if kern_type == 'swvd': key = 'lag' else: key = 'doppler' win_length = kern_params['win_length'] win_type = kern_params['win_type'] win_param = kern_params['win_param'] if l >= 3 else 0 win_param2 = kern_params['win_param2'] if l >= 4 else 1 G = get_window(win_length, win_type, win_param) G = pad_window(G, N) if kern_type == 'sqvd' and win_param2 == 0: G = np.fft.fft(G) G /= G[0] elif kern_type == 'pwvd': G = G[lag_index] g[:] = G

And I don't think you have to assign key in this loop because you don't seem to be using it.

Erikpostt · 2024-12-12T09:17:24Z

src/paradigma/heart_rate/tfd.py

+    if win_param is None:
+        win_param = []


Perhaps you could set the parameter win_param: list = [].

Erikpostt · 2024-12-12T09:19:50Z

src/paradigma/heart_rate/tfd.py

+        win_param = []
+
+    # Get the window
+    win = get_win(win_length, win_type, win_param, dft_window)


I see your get_win function here assigns an empty list to win_param if it equals None. However, in the get_win() function you assign floats to this variable. Is this working as expected?

Erikpostt · 2024-12-12T09:21:23Z

src/paradigma/heart_rate/tfd.py

+        R_even_half = np.complex128(tfd[n, :Nh]) + 1j * np.complex128(tfd[n, Nh:])
+        R_odd_half = np.complex128(tfd[n+1, :Nh]) + 1j * np.complex128(tfd[n+1, Nh:])


Suggested change

R_even_half = np.complex128(tfd[n, :Nh]) + 1j * np.complex128(tfd[n, Nh:])

R_odd_half = np.complex128(tfd[n+1, :Nh]) + 1j * np.complex128(tfd[n+1, Nh:])

R_even_half = np.complex128(tfd[n, :Nh]) + j * np.complex128(tfd[n, Nh:])

R_odd_half = np.complex128(tfd[n+1, :Nh]) + j * np.complex128(tfd[n+1, Nh:])

Erikpostt · 2024-12-12T09:21:39Z

src/paradigma/heart_rate/tfd.py

+        R_tslice_odd[N-mb] = np.conj(R_odd_half[mb])
+
+        # Perform FFT to compute time slices
+        tfd_time_slice = np.fft.fft(R_tslice_even + 1j * R_tslice_odd)


Suggested change

tfd_time_slice = np.fft.fft(R_tslice_even + 1j * R_tslice_odd)

tfd_time_slice = np.fft.fft(R_tslice_even + j * R_tslice_odd)

Erikpostt · 2024-12-12T09:23:38Z

src/paradigma/ppg_preprocessing.py

@@ -288,23 +289,23 @@ def synchronization(ppg_meta, imu_meta):

    return segment_ppg_total, segment_imu_total

-def extract_overlapping_segments(df_ppg, df_imu, time_column_ppg='time', time_column_imu='time'):
+def extract_overlapping_segments(df_ppg, df_acc, time_column_ppg='time', time_column_imu='time'):


Don't forget to set data types here too.

Erikpostt

Looking good! I have a couple of suggestions, mostly related to fixing data types and simplifying code. I would also suggest to add more comments (#) in the code to make sure the user/dev understands the processing of the data.

KarsVeldkamp added 11 commits December 3, 2024 08:36

Start heart rate estimation including tfd

0cb88b0

Merge branch 'main' of https://github.com/biomarkersParkinson/paradigma…

d1b0bca

… into heart_rate_estimation

stash updates

0c639e1

Merge branch 'main' of https://github.com/biomarkersParkinson/paradigma…

4d0b4ab

… into heart_rate_estimation

update based on merge conflicts

9b17130

update hr main function

6184107

Merge branch 'main' of https://github.com/biomarkersParkinson/paradigma…

747a427

… into heart_rate_estimation

update minor stuff matlab files

ab3e4bf

change tfd parameters to dict

44190aa

Merge branch 'main' of https://github.com/biomarkersParkinson/paradigma…

53e9665

… into heart_rate_estimation

Finalizing heart rate pipeline plus renaming preprocessing to acc ins…

bd0f46f

…tead of imu

KarsVeldkamp requested a review from Erikpostt December 11, 2024 11:33

KarsVeldkamp assigned Erikpostt Dec 11, 2024

KarsVeldkamp added 4 commits December 11, 2024 12:34

setting execution count to null

3aad804

fix output types

937ea0e

fixing pytype due to old configs

9938768

fix min_hr_samples pytype error

8ede2ae

Erikpostt reviewed Dec 12, 2024

View reviewed changes

src/paradigma/heart_rate/heart_rate_analysis.py Show resolved Hide resolved

Erikpostt reviewed Dec 12, 2024

View reviewed changes

Erikpostt requested changes Dec 12, 2024

View reviewed changes

Erikpostt assigned KarsVeldkamp and unassigned Erikpostt Dec 12, 2024

	"df_ppg_proc, df_acc_proc=preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",
	"df_ppg_proc, df_acc_proc = preprocess_ppg_data(metadatas_ppg[0], metadatas_imu[0],\n",



		def estimate_heart_rate(df: pd.DataFrame, df_ppg_preprocessed: pd.DataFrame, config:HeartRateExtractionConfig) -> pd.DataFrame:


		# Generate HR estimation time array
		rel_segment_time = df_ppg_preprocessed.time[start_idx:end_idx].values

	def assign_sqa_label(ppg_prob, config: HeartRateExtractionConfig, acc_label=None) -> np.ndarray:
	def assign_sqa_label(ppg_prob: np.ndarray, config: HeartRateExtractionConfig, acc_label: np.ndarray=None) -> np.ndarray:

		start_idx = int(np.floor((i - (samples_per_epoch - samples_shift)) / fs))
		end_idx = int(np.floor(i / fs))

-def nonsep_gdtfd(x, kern_type=None, kern_params=None):
+def nonsep_gdtfd(
+x: np.ndarray,
+kern_type: None | str = None,
+kern_params: None | dict = None
+):

	def gen_time_lag(z):
	def gen_time_lag(z: np.ndarray): -> np.ndarray


		return tfd

		def multiply_kernel_signal(tfd, kern_type, kern_params, N, Nh):

	tfd_slice = np.fft.fft(tfd[:, m]) + 1j * np.fft.fft(tfd[:, Nh + m])
	tfd_slice = np.fft.fft(tfd[:, m]) + j * np.fft.fft(tfd[:, Nh + m])


		return tfd

		def gen_doppler_lag_kern(kern_type, kern_params, N, lag_index):

		R_even_half = np.complex128(tfd[n, :Nh]) + 1j * np.complex128(tfd[n, Nh:])
		R_odd_half = np.complex128(tfd[n+1, :Nh]) + 1j * np.complex128(tfd[n+1, Nh:])

	tfd_time_slice = np.fft.fft(R_tslice_even + 1j * R_tslice_odd)
	tfd_time_slice = np.fft.fft(R_tslice_even + j * R_tslice_odd)

Heart rate estimation #85

Are you sure you want to change the base?

Heart rate estimation #85

Conversation

KarsVeldkamp commented Dec 11, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

KarsVeldkamp Dec 13, 2024 • edited Loading

Choose a reason for hiding this comment

Erikpostt Dec 13, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Erikpostt left a comment

Choose a reason for hiding this comment

Erikpostt Dec 12, 2024 •

edited

Loading

Erikpostt Dec 12, 2024 •

edited

Loading

KarsVeldkamp Dec 13, 2024 •

edited

Loading

Erikpostt Dec 13, 2024 •

edited

Loading

Erikpostt Dec 12, 2024 •

edited

Loading

Erikpostt Dec 12, 2024 •

edited

Loading

Erikpostt Dec 12, 2024 •

edited

Loading

Erikpostt Dec 12, 2024 •

edited

Loading