OSCR

Toward uncertainty-aware manual delineation of brain tumours using eye-tracking and image-derived features.

Code ↔ Paper

7 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 7 matches
  1. [1] § Materials and methods › Uncertainty quantification ↔ uncertainty_models/utils/annotate_mouse_track.py, lines 281–359 · score 0.70 · Euclidean distance, minimum distance, contour point, mouse tracking, radius, saccade
  2. [2] § Materials and methods › Uncertainty quantification ↔ uncertainty_models/utils/annotate_mouse_track_HDweighting.py, lines 281–359 · score 0.70 · Euclidean distance, minimum distance, contour point, mouse tracking, radius, saccade
  3. [3] § Materials and methods › Segmentation uncertainty prediction ↔ uncertainty_models/classification/binary_model.py, lines 127–268 · score 0.62 · Random forest, outer, Classifiers, nested, inner, splits
  4. [4] § Materials and methods › Differences between human attention and U-net saliency ↔ uncertainty_models/assess_unet_uncertainty.py, lines 1–44 · score 0.60 · Model uncertainty, Human attention, saliency maps
  5. [5] § Materials and methods › Uncertainty quantification ↔ uncertainty_models/linear_mixed_effects/model_LMR.Rmd, lines 116–161 · score 0.58 · linear mixed, random forest, variance, models, predictors, uncertainty
  6. [6] § Materials and methods › Segmentation uncertainty prediction ↔ uncertainty_models/regression/best_model.py, lines 107–183 · score 0.56 · Random forest, outer, nested, inner, splits, trained
  7. [7] § Materials and methods › Data processing ↔ unet/scripts/segmentation_test_seg_prob_atten_alllayers.py, lines 40–89 · score 0.55 · Grad CAM, feature maps, model, segmentation

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 722 lines · 27 KB · no license · 1 match

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Mon Apr 7 10:13:16 2025
  5. @author: nina1
  6. """
  8. # Resolution of input stimulus: 1488 x 1108
  9. import pandas as pd
  10. import os
  11. import numpy as np
  12. import matplotlib.pyplot as plt
  13. import seaborn as sns
  14. from PIL import Image
  15. from scipy.stats import pearsonr
  16. import matplotlib.colors as mcolors
  17. from skimage.measure import find_contours
  18. from scipy.spatial.distance import directed_hausdorff
  20. # Base path to the CSV files
  21. base_path = r"C:\Users\nina1\Documents\aaETH\MasterThesis\thesis-repo\Project_2\Data"
  23. # Base path to the png files
  24. img_path = r"C:\Users\nina1\Documents\aaETH\MasterThesis\thesis-repo\Project_2\Data_DMG\final_png"
  26. # Load the time-stamp information
  27. loop_info = pd.read_csv(os.path.join(base_path, "filtered_info_loop_final.csv"))
  28. body_info = pd.read_csv(os.path.join(base_path, "filtered_info_body.csv"),
  29. delimiter= ";")
  31. # List of pp_ids and stimulus combinations to exclude
  32. exclude_pp25 = loop_info['pp_id'] == 'pp25'
  33. exclude_pp28_stimulus = (loop_info['pp_id'] == 'pp28') & (loop_info['stimulus'] == '00051000_39')
  34. exclude_pp21_stimulus = (loop_info['pp_id'] == 'pp21') & (loop_info['stimulus'] == '00108000_47')
  35. exclude_pp16_stimulus = (loop_info['pp_id'] == 'pp16') & (loop_info['stimulus'] == '00023000_42')
  37. # Filter out the incomplete cases
  38. complete_cases = loop_info[~(exclude_pp25 | exclude_pp28_stimulus | exclude_pp21_stimulus | exclude_pp16_stimulus)]
  40. # Compute the HD's between the outlines
  41. def load_outline(stimulus_id, pp_id, base_path):
  42. filename = f"{stimulus_id}_Task2_{pp_id}_mouse_firstloop.csv"
  43. filepath = os.path.join(base_path, "csv", filename)
  44. try:
  45. df = pd.read_csv(filepath)
  46. return df[['x_shifted', 'y_shifted']].to_numpy()
  47. except FileNotFoundError:
  48. print(f"File not found: {filepath}")
  49. return None
  51. def hausdorff_distance(a, b):
  52. if a is None or b is None:
  53. return np.nan
  54. return max(
  55. directed_hausdorff(a, b)[0],
  56. directed_hausdorff(b, a)[0]
  57. )
  59. # Result storage
  60. results = []
  62. # Loop through each row in complete_cases
  63. for index, row in complete_cases.iterrows():
  64. stimulus_id = row['stimulus']
  65. pp_id = row['pp_id']
  67. # Load this participant's outline
  68. outline_a = load_outline(stimulus_id, pp_id, base_path)
  70. # Get other participants with same stimulus
  71. others = complete_cases[
  72. (complete_cases['stimulus'] == stimulus_id) &
  73. (complete_cases['pp_id'] != pp_id)
  74. ]
  76. for _, other_row in others.iterrows():
  77. other_pp_id = other_row['pp_id']
  78. outline_b = load_outline(stimulus_id, other_pp_id, base_path)
  80. hd = hausdorff_distance(outline_a, outline_b)
  82. results.append({
  83. 'stimulus_id': stimulus_id,
  84. 'pp_id': pp_id,
  85. 'other_pp_id': other_pp_id,
  86. 'hausdorff_distance': hd
  87. })
  89. # Convert to DataFrame
  90. hausdorff_df = pd.DataFrame(results)
  91. print(hausdorff_df.head())
  93. # Look into this df
  94. len(hausdorff_df["stimulus_id"].unique())
  95. len(hausdorff_df["pp_id"].unique())
  96. len(hausdorff_df["other_pp_id"].unique())
  97. print(hausdorff_df.shape)
  99. # Create a new column with sorted participant ID pairs
  100. hausdorff_df['pp_pair'] = hausdorff_df.apply(
  101. lambda row: tuple(sorted([row['pp_id'], row['other_pp_id']])), axis=1
  102. )
  104. # Get number of unique (stimulus_id, pp_pair) combinations
  105. num_unique_pairs_unordered = hausdorff_df[['stimulus_id', 'pp_pair']].drop_duplicates().shape[0]
  107. print("Number of unique unordered (stimulus_id, participant pair) combinations:", num_unique_pairs_unordered)
  109. # Sort the pp_id and other_pp_id columns to get unique unordered pairs
  110. hausdorff_df['pp_pair'] = hausdorff_df.apply(
  111. lambda row: tuple(sorted([row['pp_id'], row['other_pp_id']])), axis=1
  112. )
  114. # Filter out unique pairs (stimulus_id, pp_pair)
  115. unique_pairs_df = hausdorff_df[['stimulus_id', 'pp_pair', 'hausdorff_distance']].drop_duplicates()
  117. # Filter out any rows where Hausdorff distance is NaN or zero
  118. unique_pairs_df = unique_pairs_df[unique_pairs_df['hausdorff_distance'].notna() & (unique_pairs_df['hausdorff_distance'] > 0)]
  120. # Get Hausdorff distances, 1/HD, and 1/HD^2
  121. hausdorff_distances = unique_pairs_df['hausdorff_distance']
  122. inverse_hd = hausdorff_distances.max() - hausdorff_distances
  123. inverse_hd_squared = 1 / (hausdorff_distances ** 2)
  125. # Plot histograms
  126. plt.figure(figsize=(15, 5))
  128. # Histogram for Hausdorff distances
  129. plt.subplot(1, 3, 1)
  130. sns.histplot(hausdorff_distances, bins=20, kde=True, color='skyblue')
  131. plt.title('Histogram of Hausdorff Distances')
  132. plt.xlabel('Hausdorff Distance')
  133. plt.ylabel('Frequency')
  135. # Histogram for 1/HD
  136. plt.subplot(1, 3, 2)
  137. sns.histplot(inverse_hd, bins=20, kde=True, color='orange')
  138. plt.title('Histogram of 1/HD')
  139. plt.xlabel('1/HD')
  140. plt.ylabel('Frequency')
  142. # Histogram for 1/HD^2
  143. plt.subplot(1, 3, 3)
  144. sns.histplot(inverse_hd_squared, bins=20, kde=True, color='green')
  145. plt.title('Histogram of 1/HD^2')
  146. plt.xlabel('1/HD^2')
  147. plt.ylabel('Frequency')
  149. plt.tight_layout()
  150. plt.show()
  152. # File prefix
  153. file_prefix = "00078000_37"
  154. pp_id = "pp4" #or pp11 also nice or pp2 for 53_25, or 19_25 pp14
  156. # Image file
  157. image_path = os.path.join(img_path, f"{file_prefix}_t2f.png")
  158. image = Image.open(image_path)
  160. # Ground truth mask file
  161. ground_truth_path = r"C:\Users\nina1\Documents\aaETH\MasterThesis\thesis-repo\Project_2\Data\Mask_truthandautomated"
  162. mask_truth = np.load(os.path.join(ground_truth_path, f"{file_prefix}_truth.npy"))
  164. # Extract the contours from the mouse mask
  165. def get_contours(mask):
  166. contours = find_contours(mask, 0.5) # Get all contours
  167. return [np.array(contour) for contour in contours] # Keep separate contours
  169. contours_truth = get_contours(mask_truth)
  171. # Stack all contour points into one big array
  172. all_contour_points = np.vstack(contours_truth) # shape: (total_points, 2)
  173. contour_df = pd.DataFrame(all_contour_points[:, [1, 0]], columns=["x", "y"])
  174. # Invert the y-axis
  175. contour_df["y"] = len(mask_truth) - contour_df["y"]
  177. # Task 1 files
  178. task1_fixations = pd.read_csv(os.path.join(base_path, "csv", f"{file_prefix}_task1_{pp_id}_fixations.csv"))
  179. task1_saccades = pd.read_csv(os.path.join(base_path, "csv", f"{file_prefix}_task1_{pp_id}_saccades.csv"))
  180. task1_fixationmap = np.load(os.path.join(base_path, "fixation_maps", f"{file_prefix}_{pp_id}_task1_mask_normalized.npy"))
  182. # Task 2 files
  183. task2_fixations = pd.read_csv(os.path.join(base_path, "csv", f"{file_prefix}_task2_{pp_id}_fixations.csv"))
  184. task2_saccades = pd.read_csv(os.path.join(base_path, "csv", f"{file_prefix}_task2_{pp_id}_saccades.csv"))
  185. task2_mouse = pd.read_csv(os.path.join(base_path, "csv", f"{file_prefix}_task2_{pp_id}_mouse_firstloop.csv"))
  186. task2_fixationmap = np.load(os.path.join(base_path, "fixation_maps", f"{file_prefix}_{pp_id}_task2_mask_normalized.npy"))
  188. # Image annotations
  189. probability_map = np.load(os.path.join(base_path, "probabilities", f"{file_prefix}-probabilities.npy"))
  190. entropy_map = np.load(os.path.join(base_path, "entropy_maps", f"{file_prefix}_entropy.npy"))
  192. # Print what was loaded until here:
  193. # Quick check of data shapes
  194. print("Loaded files:")
  195. print(f"Task 1 Fixations: {task1_fixations.shape}")
  196. print(f"Task 1 Saccades: {task1_saccades.shape}")
  197. print(f"Task 1 Fixationmap: {task1_fixationmap.shape}, min value:",
  198. task1_fixationmap.min(),
  199. ", max value:",
  200. task1_fixationmap.max())
  201. print(f"Task 2 Fixations: {task2_fixations.shape}")
  202. print(f"Task 2 Saccades: {task2_saccades.shape}")
  203. print(f"Task 2 Mouse: {task2_mouse.shape}")
  204. print(f"Task 2 Fixationmap: {task2_fixationmap.shape}",
  205. task2_fixationmap.min(),
  206. ", max value:",
  207. task2_fixationmap.max())
  208. print(f"UNET probability map: {probability_map.shape}",
  209. probability_map.min(),
  210. ", max value:",
  211. probability_map.max())
  212. print(f"Image entropy map: {entropy_map.shape}",
  213. entropy_map.min(),
  214. ", max value:",
  215. entropy_map.max())
  217. # Also extract all attention maps, from all layers and summed up
  218. attention_map_path = os.path.join(base_path, "attention_maps")
  220. # Dictionary to hold the data if you want an alternative to globals()
  221. attention_maps_dict = {}
  223. # Loop through all matching files
  224. for fname in os.listdir(attention_map_path):
  225. if fname.startswith(file_prefix) and fname.endswith(".npy"):
  226. # Extract suffix (everything after the prefix and underscore, before .npy)
  227. suffix = fname[len(file_prefix)+1:].replace(".npy", "")
  228. full_path = os.path.join(attention_map_path, fname)
  230. # Load the file (use np.load or pd.read depending on your format)
  231. attention_maps_dict[suffix] = np.load(full_path)
  233. # If you really want to create variables like `entropy_map`, `saliency_map`, etc.:
  234. globals()[f"{suffix}_map"] = attention_maps_dict[suffix]
  236. # Print the shape
  237. print(f"UNET attention map from layer {suffix}: {attention_maps_dict[suffix].shape}",
  238. attention_maps_dict[suffix].min(),
  239. ", max value:",
  240. attention_maps_dict[suffix].max())
  242. # Limit to the first loop only (for task2)
  243. line_oi = complete_cases[(complete_cases["stimulus"] == file_prefix) & (complete_cases["pp_id"] == pp_id)]
  244. if line_oi["multiple_bodies"].item() == "yes":
  245. #THEN DEAL WITH THIS
  246. bodies_oi = body_info[(body_info["stimulus"] == file_prefix) & (body_info["pp_id"] == pp_id)]
  248. # Here select for each line the times where timestamp >= start_time <= endtime
  249. # Initialize an empty list to collect all body outline files
  250. outline_file = pd.DataFrame()
  252. # Loop through each body and filter task2_mouse accordingly
  253. for _, body_row in bodies_oi.iterrows():
  254. # Select times where timestamp >= start_time <= end_time for the body
  255. body_start_time = body_row["start_time"]
  256. body_end_time = body_row["end_time"]
  258. # Filter task2_mouse based on the body's start and end time
  259. body_outline_file = task2_mouse[["timestamp", "x_shifted", "y_shifted", "velocity"]]
  260. body_outline_file = body_outline_file[(body_outline_file["timestamp"] >= body_start_time) &
  261. (body_outline_file["timestamp"] <= body_end_time)]
  263. # Append the body outline file to the combined dataframe
  264. outline_file = pd.concat([outline_file, body_outline_file], ignore_index=True)
  265. else:
  266. start_time = line_oi["start_time"].item()
  267. end_time = line_oi["end_time"].item()
  269. # Start working on a mouse-file
  270. outline_file = task2_mouse[["timestamp", "x_shifted", "y_shifted", "velocity"]]
  271. outline_file = outline_file[(outline_file["timestamp"] >= start_time) & (outline_file["timestamp"] <= end_time)]
  273. # Extract the added fixation duration in that area for task 1
  274. # Create lists to store results
  275. fix_count_list = []
  276. fix_duration_list = []
  277. avg_saccade_amp_list = []
  278. avg_saccade_peakvelocity_list = []
  279. distance_truth_list = []
  281. # Loop over each point in the outline
  282. for _, outline_row in outline_file.iterrows():
  283. x_o = outline_row["x_shifted"]
  284. y_o = outline_row["y_shifted"]
  286. # Boolean mask: which fixations fall within a 20 pixel radius
  287. # Compute distance from center
  288. dx = task1_fixations["x_shifted"] - x_o
  289. dy = task1_fixations["y_shifted"] - y_o
  290. distance = np.sqrt(dx**2 + dy**2)
  292. # Boolean mask: fixations within radius 20
  293. nearby_fixations = task1_fixations[distance <= 20]
  295. # Count and sum duration
  296. fix_count = len(nearby_fixations)
  297. fix_duration = nearby_fixations["duration"].sum() if fix_count > 0 else 0
  299. # Store values
  300. fix_count_list.append(fix_count)
  301. fix_duration_list.append(fix_duration)
  303. # Distance from saccade start to (x_o, y_o)
  304. start_dist = np.sqrt((task1_saccades["sx_shifted"] - x_o)**2 +
  305. (task1_saccades["sy_shifted"] - y_o)**2)
  307. # Distance from saccade end to (x_o, y_o)
  308. end_dist = np.sqrt((task1_saccades["ex_shifted"] - x_o)**2 +
  309. (task1_saccades["ey_shifted"] - y_o)**2)
  311. # Compute distances from (x_o, y_o) to saccade start and end points
  312. start_dist = np.sqrt((task1_saccades["sx_shifted"] - x_o)**2 +
  313. (task1_saccades["sy_shifted"] - y_o)**2)
  314. end_dist = np.sqrt((task1_saccades["ex_shifted"] - x_o)**2 +
  315. (task1_saccades["ey_shifted"] - y_o)**2)
  317. # Boolean mask: saccades within 20 pixels (circular region)
  318. within_radius_mask = (start_dist <= 20) | (end_dist <= 20)
  319. nearby_saccades = task1_saccades[within_radius_mask]
  321. if not nearby_saccades.empty:
  322. # Use these for averages
  323. avg_amp = nearby_saccades["amplitude"].mean()
  324. avg_peakvel = nearby_saccades["peak_velocity"].mean()
  325. else:
  326. # Use closest point(s) instead
  327. min_start_dist = start_dist.min()
  328. min_end_dist = end_dist.min()
  330. # Boolean mask: saccades where start or end is at the closest distance
  331. closest_mask = (start_dist == min_start_dist) | (end_dist == min_end_dist)
  333. closest_saccades = task1_saccades[closest_mask]
  335. # Compute averages from saccades closest to (x_o, y_o)
  336. avg_amp = closest_saccades["amplitude"].mean()
  337. avg_peakvel = closest_saccades["peak_velocity"].mean()
  339. # Store values
  340. avg_saccade_amp_list.append(avg_amp)
  341. avg_saccade_peakvelocity_list.append(avg_peakvel)
  343. # Calculate the minimal distance to the points of the ground truth outline
  344. # Compute Euclidean distances to all contour points
  345. # Create point
  346. point = np.array([x_o, y_o])
  348. # Get contour points as (x, y) values
  349. contour_points = contour_df[["x", "y"]].values
  351. # Compute Euclidean distances from point to all contour points
  352. distances = np.linalg.norm(contour_points - point, axis=1)
  354. # Get the minimal distance
  355. min_distance = distances.min()
  357. # Get the minimum distance
  358. min_distance = distances.min()
  359. distance_truth_list.append(min_distance)
  361. # Add results to the outline_file DataFrame
  362. outline_file["fix_count_task1"] = fix_count_list
  363. outline_file["fix_duration_task1"] = fix_duration_list
  364. outline_file["avg_sacc_amplitude_task1"] = avg_saccade_amp_list
  365. outline_file["avg_sacc_peakvel_task1"] = avg_saccade_peakvelocity_list
  366. outline_file["distance_to_truth"] = distance_truth_list
  368. # Extract the added fixation duration in that area for task 2 (CURRENTLY FOR ENTIRE DURATION)
  369. # Create lists to store results
  370. fix_count_list = []
  371. fix_duration_list = []
  372. avg_saccade_amp_list = []
  373. avg_saccade_peakvelocity_list = []
  375. # Loop over each point in the outline
  376. for _, outline_row in outline_file.iterrows():
  377. x_o = outline_row["x_shifted"]
  378. y_o = outline_row["y_shifted"]
  380. # Boolean mask: which fixations fall within a 20 pixel radius
  381. # Compute distance from center
  382. dx = task2_fixations["x_shifted"] - x_o
  383. dy = task2_fixations["y_shifted"] - y_o
  384. distance = np.sqrt(dx**2 + dy**2)
  386. # Boolean mask: fixations within radius 20
  387. nearby_fixations = task2_fixations[distance <= 20]
  389. # Count and sum duration
  390. fix_count = len(nearby_fixations)
  391. fix_duration = nearby_fixations["duration"].sum() if fix_count > 0 else 0
  393. # Store values
  394. fix_count_list.append(fix_count)
  395. fix_duration_list.append(fix_duration)
  397. # Distance from saccade start to (x_o, y_o)
  398. start_dist = np.sqrt((task2_saccades["sx_shifted"] - x_o)**2 +
  399. (task2_saccades["sy_shifted"] - y_o)**2)
  401. # Distance from saccade end to (x_o, y_o)
  402. end_dist = np.sqrt((task2_saccades["ex_shifted"] - x_o)**2 +
  403. (task2_saccades["ey_shifted"] - y_o)**2)
  405. # Compute distances from (x_o, y_o) to saccade start and end points
  406. start_dist = np.sqrt((task2_saccades["sx_shifted"] - x_o)**2 +
  407. (task2_saccades["sy_shifted"] - y_o)**2)
  408. end_dist = np.sqrt((task2_saccades["ex_shifted"] - x_o)**2 +
  409. (task2_saccades["ey_shifted"] - y_o)**2)
  411. # Boolean mask: saccades within 20 pixels (circular region)
  412. within_radius_mask = (start_dist <= 20) | (end_dist <= 20)
  413. nearby_saccades = task2_saccades[within_radius_mask]
  415. if not nearby_saccades.empty:
  416. # Use these for averages
  417. avg_amp = nearby_saccades["amplitude"].mean()
  418. avg_peakvel = nearby_saccades["peak_velocity"].mean()
  419. else:
  420. # Use closest point(s) instead
  421. min_start_dist = start_dist.min()
  422. min_end_dist = end_dist.min()
  424. # Boolean mask: saccades where start or end is at the closest distance
  425. closest_mask = (start_dist == min_start_dist) | (end_dist == min_end_dist)
  427. closest_saccades = task2_saccades[closest_mask]
  429. # Compute averages from saccades closest to (x_o, y_o)
  430. avg_amp = closest_saccades["amplitude"].mean()
  431. avg_peakvel = closest_saccades["peak_velocity"].mean()
  433. # Store values
  434. avg_saccade_amp_list.append(avg_amp)
  435. avg_saccade_peakvelocity_list.append(avg_peakvel)
  437. # Add results to the outline_file DataFrame
  438. outline_file["fix_count_task2"] = fix_count_list
  439. outline_file["fix_duration_task2"] = fix_duration_list
  440. outline_file["avg_sacc_amplitude_task2"] = avg_saccade_amp_list
  441. outline_file["avg_sacc_peakvel_task2"] = avg_saccade_peakvelocity_list
  443. # Assess the number of NAs per column (there should not be any):
  444. column_nan_count = outline_file.isnull().sum()
  445. print("NaN count per column:")
  446. print(column_nan_count)
  448. # ADD information from the maps
  449. radius = 20
  450. diameter = radius * 2 + 1
  452. # Step 1: Create a circular mask
  453. yy, xx = np.ogrid[-radius:radius+1, -radius:radius+1]
  454. circle_mask = (xx**2 + yy**2) <= radius**2
  456. # Prepare output lists
  457. avg_task1_fixation = []
  458. avg_task2_fixation = []
  459. avg_entropy = []
  460. avg_attention_maps = {name: [] for name in attention_maps_dict} # dict of {name: 2D array}
  462. # Step 2: Loop over outline points
  463. for _, row in outline_file.iterrows():
  464. x_o = int(round(row["x_shifted"]))
  465. y_o = int(round(row["y_shifted"]))
  467. # Define bounding box
  468. x_start, x_end = x_o - radius, x_o + radius + 1
  469. y_start, y_end = y_o - radius, y_o + radius + 1
  471. # Helper to extract and mask the region
  472. def extract_avg(img):
  473. h, w = img.shape
  474. if x_start < 0 or y_start < 0 or x_end > w or y_end > h:
  475. return np.nan # out of bounds
  476. region = img[y_start:y_end, x_start:x_end]
  477. return region[circle_mask].mean()
  479. avg_task1_fixation.append(extract_avg(task1_fixationmap))
  480. avg_task2_fixation.append(extract_avg(task2_fixationmap))
  481. avg_entropy.append(extract_avg(entropy_map))
  483. for name, amap in attention_maps_dict.items():
  484. avg_attention_maps[name].append(extract_avg(amap))
  486. # Step 3: Add to DataFrame
  487. outline_file["avg_task1_fix"] = avg_task1_fixation
  488. outline_file["avg_task2_fix"] = avg_task2_fixation
  489. outline_file["avg_entropy"] = avg_entropy
  491. for name, values in avg_attention_maps.items():
  492. outline_file[f"avg_{name}"] = values
  494. # Assess the number of NAs per column (there should not be any):
  495. column_nan_count = outline_file.isnull().sum()
  496. print("NaN count per column:")
  497. print(column_nan_count)
  499. # Add interobserver variability, consider only the participants with DICE >0.7
  500. # Before this: 143 pp-stimuli pairs
  501. # After this: still 94 pp-stimuli pairs
  502. # 1. Filter loop_info_first for DICE > 0.7
  503. loop_info_highDICE = loop_info_first[loop_info_first["DICE_truth"] > 0.7]
  505. # 2. Get participant IDs for same stimulus and different pp_id
  506. pp_ids_oi = loop_info_highDICE["pp_id"][
  507. (loop_info_highDICE["stimulus"] == file_prefix) &
  508. (loop_info_highDICE["pp_id"] != pp_id)
  509. ]
  511. # 3. Load all comparison outlines for this stimulus
  512. other_pp_outlines = []
  514. for pp in pp_ids_oi:
  515. file_path = os.path.join(base_path, "csv", f"{file_prefix}_task2_{pp}_mouse_firstloop.csv")
  516. if os.path.exists(file_path):
  517. df = pd.read_csv(file_path)
  518. other_pp_outlines.append(df[["x_shifted", "y_shifted"]].values)
  520. # 4. Compute variability for each point in the current outline
  521. variability_list = []
  523. for _, outline_row in outline_file.iterrows():
  524. x_o = outline_row["x_shifted"]
  525. y_o = outline_row["y_shifted"]
  526. point = np.array([x_o, y_o])
  528. # Store all minimal distances to this point across other participant outlines
  529. min_dists = []
  531. for other_outline in other_pp_outlines:
  532. # Euclidean distances to all points in this other outline
  533. dists = np.linalg.norm(other_outline - point, axis=1)
  534. min_dists.append(dists.min()) # Closest point on this outline
  536. # Median across all other outlines
  537. if min_dists:
  538. variability_list.append(np.median(min_dists))
  539. else:
  540. variability_list.append(np.nan)
  542. # 5. Add to DataFrame
  543. outline_file["variability_median_min_dist"] = variability_list
  546. # Select only continuous variables (excluding 'timestamp', 'x_shifted', 'y_shifted')
  547. continuous_vars = outline_file.drop(columns=['timestamp', 'x_shifted', 'y_shifted'])
  549. # Step 1: Compute the correlation matrix
  550. corr_matrix = continuous_vars.corr()
  552. # Step 2: Compute p-values for correlation significance
  553. def compute_p_value(x, y):
  554. return pearsonr(x, y)[1]
  556. p_values = continuous_vars.corr(method=lambda x, y: compute_p_value(x, y)) # Get p-values
  558. # Step 3: Handle missing data for saccade columns by excluding rows with NaN in these columns
  559. # Create a mask for NaN in saccade columns (fixation columns are kept as is)
  560. mask_saccades = continuous_vars[['avg_sacc_amplitude_task1', 'avg_sacc_peakvel_task1',
  561. 'avg_sacc_amplitude_task2', 'avg_sacc_peakvel_task2']].notna()
  563. # Apply mask only to saccade-related columns
  564. mask = mask_saccades.all(axis=1)
  565. filtered_continuous_vars = continuous_vars[mask]
  567. # Recompute correlation matrix and p-values after filtering
  568. corr_matrix_filtered = filtered_continuous_vars.corr()
  569. p_values_filtered = filtered_continuous_vars.corr(method=lambda x, y: compute_p_value(x, y))
  571. # Step 4: Define significance stars function
  572. def significance_stars(p):
  573. if p < 0.001:
  574. return "***"
  575. elif p < 0.01:
  576. return "**"
  577. elif p < 0.05:
  578. return "*"
  579. else:
  580. return ""
  582. # Step 5: Generate the annotation for the heatmap
  583. # Format correlation values and add significance stars
  584. annot = p_values_filtered.applymap(significance_stars)
  585. #corr_annot = corr_matrix_filtered.round(2).astype(str) + annot
  586. corr_annot = annot # only significance start
  588. # Step 6: Plot the heatmap
  589. plt.figure(figsize=(12, 10))
  590. sns.heatmap(corr_matrix_filtered, annot=corr_annot, fmt="", cmap="coolwarm", center=0, linewidths=0.5, vmin=-1, vmax=1)
  592. # Title
  593. plt.title("Correlation Heatmap with Significance Levels (***: p < 0.001, **: p < 0.01. *: p < 0.05)", fontsize=14)
  595. plt.show()
  597. # Plot this information
  598. plt.scatter(outline_file["fix_count_task1"], outline_file["fix_count_task2"])
  600. # Add labels and title for clarity
  601. plt.xlabel('Fixation Count (Task 1)')
  602. plt.ylabel('Fixation Count (Task 2)')
  604. # Display the plot
  605. plt.show()
  607. # Function to plot saccades, fixations, and mouse track annotations
  608. def plot_saccades_and_fixations(image, saccades, fixations, title="Plot", output_path=None):
  609. # Create a figure and axis for the plot
  610. fig, ax = plt.subplots(figsize=(8, 8))
  611. ax.imshow(image) # Display the image
  613. # Plot saccades
  614. for _, row in saccades.iterrows():
  615. sx, sy, ex, ey = row['sx_shifted'], row['sy_shifted'], row['ex_shifted'], row['ey_shifted']
  616. ax.plot([sx, ex], [sy, ey],
  617. color='gold',
  618. alpha = 0.5,
  619. linewidth=1)
  621. # Plot fixations
  622. for _, row in fixations.iterrows():
  623. x, y, duration = row['x_shifted'], row['y_shifted'], row['duration']
  624. radius = np.sqrt(duration) * 0.5
  625. circle = plt.Circle((x, y), radius, color='violet', alpha=0.9, fill=False, linewidth=1.5)
  626. ax.add_patch(circle)
  628. # Title and axis settings
  629. ax.set_title(title, fontsize=14)
  630. ax.axis("off")
  632. # Save or display the plot
  633. #if output_path:
  634. #plt.savefig(output_path, bbox_inches='tight')
  635. plt.show()
  637. # Plot for task1
  638. plot_saccades_and_fixations(
  639. image=image, # Load your image here
  640. saccades=task1_saccades, # Load saccades dataframe here
  641. fixations=task1_fixations, # Load fixations dataframe here
  642. title="Saccades and Fixations Visualization (task 1)",
  643. output_path=None # If you want to save, provide the path
  644. )
  646. # Plot for task2
  647. plot_saccades_and_fixations(
  648. image=image, # Load your image here
  649. saccades=task2_saccades, # Load saccades dataframe here
  650. fixations=task2_fixations, # Load fixations dataframe here
  651. title="Saccades and Fixations Visualization (task2)",
  652. output_path=None # If you want to save, provide the path
  653. )
  655. # Create a truncated version of the magma colormap
  656. def truncate_colormap(cmap, minval=0.1, maxval=1.0, n=100):
  657. """
  658. Truncates a colormap so that it starts at minval and ends at maxval.
  659. """
  660. new_cmap = mcolors.LinearSegmentedColormap.from_list(
  661. f"truncated_{cmap.name}", cmap(np.linspace(minval, maxval, n))
  662. )
  663. return new_cmap
  665. # Use magma colormap and truncate it
  666. cmap = plt.get_cmap('magma')
  667. cmap_truncated = truncate_colormap(cmap, minval=0.2) # Adjust minval as needed to start from purple
  669. # Function to plot mouse track annotations
  670. def plot_mouse_track_annotations(image, outline_file, annot_column, title="Plot", output_path=None):
  671. # Create a figure and axis for the plot
  672. fig, ax = plt.subplots(figsize=(8, 8))
  673. ax.imshow(image) # Display the image
  675. # Normalize the annotation column values for coloring
  676. norm = plt.Normalize(vmin=outline_file[annot_column].min(), vmax=outline_file[annot_column].max())
  677. cmap = cmap_truncated # You can use other color maps like 'coolwarm', 'plasma', etc.
  679. # Plot mouse track (annotate by the specified column)
  680. scatter = ax.scatter(outline_file['x_shifted'], outline_file['y_shifted'],
  681. c=outline_file[annot_column], cmap=cmap, norm=norm, s=10, alpha=0.7)
  683. # Add a smaller colorbar to the plot for better understanding of the metric values
  684. cbar = plt.colorbar(scatter, ax=ax, orientation='vertical', fraction=0.02, pad=0.04) # Adjust fraction and pad
  685. cbar.set_label(annot_column, fontsize=10)
  687. # Set the title to include the annotation column
  688. ax.set_title(f"{title} - Annotated by {annot_column}", fontsize=14)
  690. # Remove axes
  691. ax.axis("off")
  693. # Save or display the plot
  694. #if output_path:
  695. #plt.savefig(output_path, bbox_inches='tight')
  696. plt.show()
  698. # Function to plot mouse track annotations for all columns in outline_file
  699. def plot_for_all_columns(image, outline_file, title="Mouse Track with Annotations", output_path=None):
  700. # Iterate over each column in outline_file (excluding columns like 'x_shifted', 'y_shifted')
  701. for column in outline_file.columns:
  702. # Skip the columns that are not suitable for annotation (e.g., 'x_shifted', 'y_shifted', etc.)
  703. if column in ['x_shifted', 'y_shifted', 'timestamp']: # Adjust as necessary
  704. continue
  706. # Call the plot function for each column
  707. plot_mouse_track_annotations(
  708. image=image,
  709. outline_file=outline_file,
  710. annot_column=column,
  711. title=f"{title} - Annotated by {column}",
  712. output_path=output_path # You can provide a path to save the plot
  713. )
  715. # Example usage
  716. plot_for_all_columns(
  717. image=image, # Load your image here
  718. outline_file=outline_file, # Load outline_file dataframe here
  719. title="Mouse Track with Annotations", # Title for the plot
  720. output_path=None # If you want to save, provide the path
  721. )

annotate_mouse_track.py at commit 4bd8e5f, no license · at the source

Overview

Authors: Nina Baumgartner1, Daria Laslo1,2, Laura Fontanesi3, Catherine R Jutzeler1,2, Arzu Çöltekin3, Sarah Brüningk4,5
  1. ETH Zurich, Rämistrasse101, 8092 Zürich, Switzerland
  2. Swiss Institute of Bioinformatics, Lagerstrasse 5, Lausanne, Switzerland
  3. Fachhochschule Nordwestschweiz FHNW, Hochschule für Informatik, 5210 Windisch, Switzerland
  4. Department of Radiation Oncology, Inselspital, Bern University Hospital and University of Bern, Switzerland
  5. Department of Digital Medicine, University of Bern, Bern, Switzerland
Institutions: ETH Zurich (Switzerland); SIB Swiss Institute of Bioinformatics (Switzerland); FHNW University of Applied Sciences and Arts Northwestern Switzerland (Switzerland); University of Bern (Switzerland); University Hospital of Bern (Switzerland)
Journal: Physics and imaging in radiation oncology, volume 40, article 101056
Dates: received 12 February 2026; accepted 3 August 2026; published online 4 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.phro.2026.101056 · PMID 42630840 · PMCID PMC13495590 · OpenAlex W7172425191
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: mouse (organism), other condition (population)
Methods: Connectivity, Statistics, Machine learning, Graphs, Physiology & signal measures
Keywords: Tumour segmentation, Segmentation uncertainty, Eye-tracking, Mouse-tracking, Paediatric brain tumour
Topic: Gaze Tracking and Assistive Technology (Human-Computer Interaction, Computer Science), according to OpenAlex
Funding: Swiss National Science Foundation (225913)
Citations: not cited yet (Europe PMC); 46 references in the paper

Abstract

Background and Purpose: Accurate tumour delineation is key in radiotherapy workflows. Concurrently, diffuse tumour types are inherently difficult to delineate, rendering contour uncertainty information highly valuable for downstream treatment planning. In this study, we investigated whether uncertainty in manually delineated tumour contours can be inferred from clinician behaviour (eye and mouse movements) and image-derived indicators.

Materials and Methods: In a two-stage controlled experiment, 36 clinical imaging experts described and manually delineated brain tumours on T2-FLAIR (fluid-attenuated inversion recovery) MRI scans, while their eye and mouse movements were recorded. Inter-observer contour variability was used as a proxy for contour uncertainty. In addition, we extracted image-derived features, including U-Net saliency maps, pixel-wise U-Net segmentation probabilities, and image entropy. To assess and predict contour uncertainty, we applied mixed-effects models and machine learning algorithms.

Results: Higher contour uncertainty was associated with higher saccade velocities and greater fixation density. Uncertainty was also significantly correlated with segmentation error and image-derived features (p < 0.05). A random forest regressor, combining behavioural and image-derived features, explained 39% of the variance in contour uncertainty. Notably, features derived from downsampling layers were the strongest predictors, despite displaying the lowest saliency overlap with human attention.

Conclusions: Our results suggest that uncertainty in manually delineated tumour contours can be estimated using behavioural and image-derived features, without explicit uncertainty annotations. While clinical deployment will require validation under realistic acquisition conditions and with specialty experts, these findings established the feasibility of passively inferred uncertainty as a foundation for future uncertainty-aware delineation tools.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 7 matches between paragraphs and lines of code.

gitlab.ethz.ch/bmdslab/publications/oncology/manual-segmentation-uncertainty-using-eyetracking

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 4bd8e5f9b43bf98c89833865c088dc2254f99204, 29 May 2026
Languages: Python (29), Shell (3), R (1)
Size: 36 files, 33 scripts
Software Heritage: not archived
Found in: the text, “Differences between human attention and U-net sa”
Holds: README, environment (environment.yml), 1 notebook
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (26 files), Matplotlib (20 files), pandas (19 files), SciPy (12 files), Pillow (9 files), scikit-image (9 files), seaborn (9 files), NiBabel (8 files), PyTorch (5 files), scikit-learn (4 files), XGBoost (2 files), brms (1 file), car (1 file), easystats (1 file), lme4 (1 file), lmerTest (1 file), OpenCV (1 file), randomForest (1 file), tidyverse (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
34 files
At the source: gitlab.ethz.ch/BMDSlab/publications/oncology/manual-segmentation-uncertainty-using-eyetracking

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 33 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data sharing

Imaging data is publicly available at https://synapse.org/Synapse:syn51156910 upon request. The acquired eye and mouse tracking data is available upon request from the senior authors (contact Prof. Sarah Brüningk, University of Bern, ; Prof. Arzu Coltekin, University of Applied Sciences and Arts Northwestern Switzerland, ).

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 6 authors, 5 keywords, 1 funder, 39 references.

Cite

This paper

Baumgartner, N., Laslo, D., Fontanesi, L., Jutzeler, C. R., Çöltekin, A., & Brüningk, S. (2026). Toward uncertainty-aware manual delineation of brain tumours using eye-tracking and image-derived features. Physics and imaging in radiation oncology, 40, 101056. https://doi.org/10.1016/j.phro.2026.101056

BibTeX

@article{baumgartner2026toward,
author = {Baumgartner, Nina and Laslo, Daria and Fontanesi, Laura and Jutzeler, Catherine R and Çöltekin, Arzu and Brüningk, Sarah},
title = {{Toward uncertainty-aware manual delineation of brain tumours using eye-tracking and image-derived features}},
journal = {Physics and imaging in radiation oncology},
year = {2026},
month = jul,
volume = {40},
pages = {101056},
publisher = {Elsevier},
issn = {2405-6316},
doi = {10.1016/j.phro.2026.101056},
url = {https://doi.org/10.1016/j.phro.2026.101056},
pmid = {42630840},
pmcid = {PMC13495590}
}

RIS

TY - JOUR
AU - Baumgartner, Nina
AU - Laslo, Daria
AU - Fontanesi, Laura
AU - Jutzeler, Catherine R
AU - Çöltekin, Arzu
AU - Brüningk, Sarah
TI - Toward uncertainty-aware manual delineation of brain tumours using eye-tracking and image-derived features
T2 - Physics and imaging in radiation oncology
J2 - Phys Imaging Radiat Oncol
PY - 2026
DA - 2026/07/01
VL - 40
SP - 101056
SN - 2405-6316
PB - Elsevier
DO - 10.1016/j.phro.2026.101056
UR - https://doi.org/10.1016/j.phro.2026.101056
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.phro.2026.101056",
"type": "article-journal",
"title": "Toward uncertainty-aware manual delineation of brain tumours using eye-tracking and image-derived features",
"container-title": "Physics and imaging in radiation oncology",
"author": [
{
"family": "Baumgartner",
"given": "Nina"
},
{
"family": "Laslo",
"given": "Daria"
},
{
"family": "Fontanesi",
"given": "Laura"
},
{
"family": "Jutzeler",
"given": "Catherine R"
},
{
"family": "Çöltekin",
"given": "Arzu"
},
{
"family": "Brüningk",
"given": "Sarah"
}
],
"container-title-short": "Phys Imaging Radiat Oncol",
"volume": "40",
"page": "101056",
"DOI": "10.1016/j.phro.2026.101056",
"PMID": "42630840",
"PMCID": "PMC13495590",
"ISSN": "2405-6316",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.phro.2026.101056",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: randomForest, brms, XGBoost, 12 other tools, mouse
[2] doi:10.1038/s41598-026-48496-1 [code]
A unified FLAIR hyperintensity segmentation model for various CNS tumor types and acquisition time points.
Journal: Scientific reports
In common: scikit-image, Pillow, NiBabel, 6 other tools, synapse.org/synapse:syn51156910, other condition, 2 references
[3] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: car, lmerTest, lme4, 10 other tools, other condition
[4] doi:10.1016/j.nicl.2026.104012 [code]
Structural-functional multilayer brain network properties and outcome of combined repetitive transcranial magnetic stimulation and psychotherapy for obsessive-compulsive disorder.
Journal: NeuroImage. Clinical
In common: XGBoost, car, lmerTest, 9 other tools, other condition
[5] doi:10.34133/csbj.0042 [code]
Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials.
Journal: Computational and structural biotechnology journal
In common: easystats, car, lmerTest, 9 other tools, other condition
[6] doi:10.1093/braincomms/fcag176 [code]
Tau topography subtypes account for clinical heterogeneity and longitudinal trajectories in early-onset Alzheimer's disease.
Journal: Brain communications
In common: easystats, car, lmerTest, 9 other tools
[7] doi:10.1038/s41467-026-73865-9 [code]
Histamine shapes the neurocomputational dynamics of human learning.
Journal: Nature communications
In common: brms, easystats, car, 8 other tools
[8] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: easystats, car, lmerTest, 9 other tools
[9] doi:10.1162/imag.a.1347 [code]
Neural and behavioural correlates of theory of mind reasoning in five-year-old children born preterm.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: brms, easystats, lmerTest, 8 other tools, other condition
[10] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: XGBoost, OpenCV, scikit-image, 9 other tools, other condition

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.