OSCR

Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.

Code ↔ Paper

3 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 3 matches
  1. [1] § Methods and Materials › Model performance evaluation ↔ metrics.py, lines 113–254 · score 0.81 · ground truth, GT lesion, positive lesions, predicted segmentations, score, FP
  2. [2] § Methods and Materials › Model performance evaluation ↔ metrics.py, lines 113–254 · score 0.66 · TP lesion, FN lesion, Hausdorff, FP, BraTS, HD95
  3. [3] § Methods and Materials › Convolutional neural network ↔ nnunetv2/training/nnUNetTrainer/nnUNetTrainer.py, lines 168–229 · score 0.58 · deep learning, network architecture, hyperparameter, image segmentation, weights, training

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 · 408 lines · 14 KB · no license · 2 matches

  1. import numpy as np
  2. import nibabel as nib
  3. import cc3d
  4. import scipy
  5. import os
  6. import pandas as pd
  7. import surface_distance
  8. import sys
  9. import math
  11. def dice(im1, im2):
  12. """
  13. Computes Dice score for two images
  15. Parameters
  16. ==========
  17. im1: Numpy Array/Matrix; Predicted segmentation in matrix form
  18. im2: Numpy Array/Matrix; Ground truth segmentation in matrix form
  20. Output
  21. ======
  22. dice_score: Dice score between two images
  23. """
  25. im1 = np.asarray(im1).astype(bool)
  26. im2 = np.asarray(im2).astype(bool)
  28. if im1.shape != im2.shape:
  29. raise ValueError("Shape mismatch: im1 and im2 must have the same shape.")
  31. # Compute Dice coefficient
  32. intersection = np.logical_and(im1, im2)
  34. return 2. * (intersection.sum()) / (im1.sum() + im2.sum())
  36. def get_TissueWiseSeg(prediction_matrix, gt_matrix, tissue_type):
  37. """
  38. Converts the segmentatations to isolate tissue types
  40. Parameters
  41. ==========
  42. prediction_matrix: Numpy Array/Matrix; Predicted segmentation in matrix form
  43. gt_matrix: Numpy Array/Matrix; Ground truth segmentation in matrix form
  44. tissue_type: str; Can be WT, ET or TC
  46. Output
  47. ======
  48. prediction_matrix: Numpy Array/Matrix; Predicted segmentation in matrix form with
  49. just tissue type mentioned
  50. gt_matrix: Numpy Array/Matrix; Ground truth segmentation in matrix form with just
  51. tissue type mentioned
  52. """
  54. if tissue_type == 'WT':
  55. np.place(prediction_matrix, (prediction_matrix != 1) & (prediction_matrix != 2) & (prediction_matrix != 3), 0)
  56. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  58. np.place(gt_matrix, (gt_matrix != 1) & (gt_matrix != 2) & (gt_matrix != 3), 0)
  59. np.place(gt_matrix, (gt_matrix > 0), 1)
  61. elif tissue_type == 'TC':
  62. np.place(prediction_matrix, (prediction_matrix != 1) & (prediction_matrix != 3), 0)
  63. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  65. np.place(gt_matrix, (gt_matrix != 1) & (gt_matrix != 3), 0)
  66. np.place(gt_matrix, (gt_matrix > 0), 1)
  68. elif tissue_type == 'ET':
  69. np.place(prediction_matrix, (prediction_matrix != 3), 0)
  70. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  72. np.place(gt_matrix, (gt_matrix != 3), 0)
  73. np.place(gt_matrix, (gt_matrix > 0), 1)
  75. return prediction_matrix, gt_matrix
  78. def get_GTseg_combinedByDilation(gt_dilated_cc_mat, gt_label_cc):
  79. """
  80. Computes the Corrected Connected Components after combing lesions
  81. together with respect to their dilation extent
  83. Parameters
  84. ==========
  85. gt_dilated_cc_mat: Numpy Array/Matrix; Ground Truth Dilated Segmentation
  86. after CC Analysis
  87. gt_label_cc: Numpy Array/Matrix; Ground Truth Segmentation after
  88. CC Analysis
  90. Output
  91. ======
  92. gt_seg_combinedByDilation_mat: Numpy Array/Matrix; Ground Truth
  93. Segmentation after CC Analysis and
  94. combining lesions
  95. """
  98. gt_seg_combinedByDilation_mat = np.zeros_like(gt_dilated_cc_mat)
  100. for comp in range(np.max(gt_dilated_cc_mat)):
  101. comp += 1
  103. gt_d_tmp = np.zeros_like(gt_dilated_cc_mat)
  104. gt_d_tmp[gt_dilated_cc_mat == comp] = 1
  105. gt_d_tmp = (gt_label_cc*gt_d_tmp)
  107. np.place(gt_d_tmp, gt_d_tmp > 0, comp)
  108. gt_seg_combinedByDilation_mat += gt_d_tmp
  110. return gt_seg_combinedByDilation_mat
  113. def get_LesionWiseScores(prediction_seg, gt_seg, label_value, dil_factor):
  114. """
  115. Computes the Lesion-wise scores for pair of prediction and ground truth
  116. segmentations
  118. Parameters
  119. ==========
  120. prediction_seg: str; location of the prediction segmentation
  121. gt_label_cc: str; location of the gt segmentation
  122. label_value: str; Can be WT, ET or TC
  123. dil_factor: int; Used to perform dilation
  125. Output
  126. ======
  127. tp: Number of TP lesions WRT prediction segmentation
  128. fn: Number of FN lesions WRT prediction segmentation
  129. fp: Number of FP lesions WRT prediction segmentation
  130. gt_tp: Number of Ground Truth TP lesions WRT prediction segmentation
  131. metric_pairs: list; All the lesion-wise metrics
  132. full_dice: Dice Score of the pair of segmentations
  133. full_gt_vol: Total Ground Truth Segmenatation Volume
  134. full_pred_vol: Total Prediction Segmentation Volume
  135. """
  137. ## Get Prediction and GT segs matrix files
  138. pred_nii = nib.load(prediction_seg)
  139. gt_nii = nib.load(gt_seg)
  140. pred_mat = pred_nii.get_fdata()
  141. gt_mat = gt_nii.get_fdata()
  143. ## Get Spacing to computes volumes
  144. ## Brats Assumes all spacing is 1x1x1mm3
  145. sx, sy, sz = pred_nii.header.get_zooms()
  147. ## Get the prediction and GT matrix based on
  148. ## WT, TC, ET
  150. pred_mat, gt_mat = get_TissueWiseSeg(
  151. prediction_matrix = pred_mat,
  152. gt_matrix = gt_mat,
  153. tissue_type = label_value
  154. )
  156. ## Get Dice score for the full image
  157. if np.all(gt_mat==0) and np.all(pred_mat==0):
  158. full_dice = 1.0
  159. else:
  160. full_dice = dice(
  161. pred_mat,
  162. gt_mat
  163. )
  165. ## Get HD95 sccre for the full image
  167. if np.all(gt_mat==0) and np.all(pred_mat==0):
  168. full_hd95 = 0.0
  169. else:
  170. full_sd = surface_distance.compute_surface_distances(gt_mat.astype(int),
  171. pred_mat.astype(int),
  172. (sx,sy,sz))
  173. full_hd95 = surface_distance.compute_robust_hausdorff(full_sd, 95)
  175. ## Get Sensitivity and Specificity
  176. full_sens, full_specs = get_sensitivity_and_specificity(result_array = pred_mat,
  177. target_array = gt_mat)
  179. ## Get GT Volume and Pred Volume for the full image
  180. full_gt_vol = np.sum(gt_mat)*sx*sy*sz
  181. full_pred_vol = np.sum(pred_mat)*sx*sy*sz
  183. ## Performing Dilation and CC analysis
  185. dilation_struct = scipy.ndimage.generate_binary_structure(3, 2)
  187. gt_mat_cc = cc3d.connected_components(gt_mat, connectivity=26)
  188. pred_mat_cc = cc3d.connected_components(pred_mat, connectivity=26)
  190. gt_mat_dilation = scipy.ndimage.binary_dilation(gt_mat, structure = dilation_struct, iterations = dil_factor)
  191. gt_mat_dilation_cc = cc3d.connected_components(gt_mat_dilation, connectivity=26)
  193. gt_mat_combinedByDilation = get_GTseg_combinedByDilation(
  194. gt_dilated_cc_mat = gt_mat_dilation_cc,
  195. gt_label_cc = gt_mat_cc
  196. )
  198. ## Performing the Lesion-By-Lesion Comparison
  200. gt_label_cc = gt_mat_combinedByDilation
  201. pred_label_cc = pred_mat_cc
  203. gt_tp = []
  204. tp = []
  205. fn = []
  206. fp = []
  207. metric_pairs = []
  209. for gtcomp in range(np.max(gt_label_cc)):
  210. gtcomp += 1
  212. ## Extracting current lesion
  213. gt_tmp = np.zeros_like(gt_label_cc)
  214. gt_tmp[gt_label_cc == gtcomp] = 1
  216. ## Extracting ROI GT lesion component
  217. gt_tmp_dilation = scipy.ndimage.binary_dilation(gt_tmp, structure = dilation_struct, iterations = dil_factor)
  219. # Volume of lesion
  220. gt_vol = np.sum(gt_tmp)*sx*sy*sz
  222. ## Extracting Predicted true positive lesions
  223. pred_tmp = np.copy(pred_label_cc)
  224. #pred_tmp = pred_tmp*gt_tmp
  225. pred_tmp = pred_tmp*gt_tmp_dilation
  226. intersecting_cc = np.unique(pred_tmp)
  227. intersecting_cc = intersecting_cc[intersecting_cc != 0]
  228. for cc in intersecting_cc:
  229. tp.append(cc)
  231. ## Isolating Predited Lesions to calulcate Metrics
  232. pred_tmp = np.copy(pred_label_cc)
  233. pred_tmp[np.isin(pred_tmp,intersecting_cc,invert=True)] = 0
  234. pred_tmp[np.isin(pred_tmp,intersecting_cc)] = 1
  236. ## Calculating Lesion-wise Dice and HD95
  237. dice_score = dice(pred_tmp, gt_tmp)
  238. surface_distances = surface_distance.compute_surface_distances(gt_tmp, pred_tmp, (sx,sy,sz))
  239. hd = surface_distance.compute_robust_hausdorff(surface_distances, 95)
  241. metric_pairs.append((intersecting_cc,
  242. gtcomp, gt_vol, dice_score, hd))
  244. ## Extracting Number of TP/FP/FN and other data
  245. if len(intersecting_cc) > 0:
  246. gt_tp.append(gtcomp)
  247. else:
  248. fn.append(gtcomp)
  250. fp = np.unique(
  251. pred_label_cc[np.isin(
  252. pred_label_cc,tp+[0],invert=True)])
  254. return tp, fn, fp, gt_tp, metric_pairs, full_dice, full_hd95, full_gt_vol, full_pred_vol, full_sens, full_specs
  257. def get_sensitivity_and_specificity(result_array, target_array):
  258. """
  259. This function is extracted from GaNDLF from mlcommons
  261. You can find the documentation here -
  263. https://github.com/mlcommons/GaNDLF/blob/master/GANDLF/metrics/segmentation.py#L196
  265. """
  266. iC = np.sum(result_array)
  267. rC = np.sum(target_array)
  269. overlap = np.where((result_array == target_array), 1, 0)
  271. # Where they agree are both equal to that value
  272. TP = overlap[result_array == 1].sum()
  273. FP = iC - TP
  274. FN = rC - TP
  275. TN = np.count_nonzero((result_array != 1) & (target_array != 1))
  277. Sens = 1.0 * TP / (TP + FN + sys.float_info.min)
  278. Spec = 1.0 * TN / (TN + FP + sys.float_info.min)
  280. # Make Changes if both input and reference are 0 for the tissue type
  281. if (iC == 0) and (rC == 0):
  282. Sens = 1.0
  284. return Sens, Spec
  288. def get_LesionWiseResults(pred_file, gt_file, challenge_name, output=None):
  289. """
  290. Computes the Lesion-wise scores for pair of prediction and ground truth
  291. segmentations
  293. Parameters
  294. ==========
  295. pred_file: str; location of the prediction segmentation
  296. gt_file: str; location of the gt segmentation
  297. challenge_name: str; name of the challenge for parameters
  300. Output
  301. ======
  302. Saves the performance metrics as CSVs
  303. results_df: pd.DataFrame; lesion-wise results with other metrics
  304. """
  306. ## Dilation and Threshold Parameters
  307. if challenge_name == 'BraTS-GLI':
  308. dilation_factor = 3
  309. lesion_volume_thresh = 50
  310. elif challenge_name == 'BraTS-SSA':
  311. dilation_factor = 3
  312. lesion_volume_thresh = 50
  313. elif challenge_name == 'BraTS-MEN':
  314. dilation_factor = 1
  315. lesion_volume_thresh = 50
  316. elif challenge_name == 'BraTS-PED':
  317. dilation_factor = 3
  318. lesion_volume_thresh = 50
  319. elif challenge_name == 'BraTS-MET':
  320. dilation_factor = 1
  321. lesion_volume_thresh = 2
  324. final_lesionwise_metrics_df = pd.DataFrame()
  325. final_metrics_dict = dict()
  326. label_values = ['WT', 'TC', 'ET']
  328. for l in range(len(label_values)):
  329. tp, fn, fp, gt_tp, metric_pairs, full_dice, full_hd95, full_gt_vol, full_pred_vol, full_sens, full_specs = get_LesionWiseScores(
  330. prediction_seg = pred_file,
  331. gt_seg = gt_file,
  332. label_value = label_values[l],
  333. dil_factor = dilation_factor
  334. )
  336. metric_df = pd.DataFrame(
  337. metric_pairs, columns=['predicted_lesion_numbers', 'gt_lesion_numbers',
  338. 'gt_lesion_vol', 'dice_lesionwise', 'hd95_lesionwise']
  339. ).sort_values(by = ['gt_lesion_numbers'], ascending=True).reset_index(drop = True)
  341. metric_df['_len'] = metric_df['predicted_lesion_numbers'].map(len)
  343. ## Removing <= 50 lesions from analysis
  344. fn_sub = (metric_df[(metric_df['_len'] == 0) &
  345. (metric_df['gt_lesion_vol'] <= lesion_volume_thresh)
  346. ]).shape[0]
  349. gt_tp_sub = (metric_df[(metric_df['_len'] != 0) &
  350. (metric_df['gt_lesion_vol'] <= lesion_volume_thresh)
  351. ]).shape[0]
  354. metric_df['Label'] = [label_values[l]]*len(metric_df)
  355. metric_df = metric_df.replace(np.inf, 374)
  357. final_lesionwise_metrics_df = final_lesionwise_metrics_df.append(metric_df)
  358. metric_df_thresh = metric_df[metric_df['gt_lesion_vol'] > lesion_volume_thresh]
  360. try:
  361. lesion_wise_dice = np.sum(metric_df_thresh['dice_lesionwise'])/(len(metric_df_thresh) + len(fp))
  362. except:
  363. lesion_wise_dice = np.nan
  365. try:
  366. lesion_wise_hd95 = (np.sum(metric_df_thresh['hd95_lesionwise']) + len(fp)*374)/(len(metric_df_thresh) + len(fp))
  367. except:
  368. lesion_wise_hd95 = np.nan
  370. if math.isnan(lesion_wise_dice):
  371. lesion_wise_dice = 1
  373. if math.isnan(lesion_wise_hd95):
  374. lesion_wise_hd95 = 0
  376. metrics_dict = {
  377. 'Num_TP' : len(gt_tp) - gt_tp_sub, # GT_TP
  378. #'Num_TP' : len(tp),
  379. 'Num_FP' : len(fp),
  380. 'Num_FN' : len(fn) - fn_sub,
  381. 'Sensitivity': full_sens,
  382. 'Specificity': full_specs,
  383. 'Legacy_Dice' : full_dice,
  384. 'Legacy_HD95' : full_hd95,
  385. 'GT_Complete_Volume' : full_gt_vol,
  386. 'LesionWise_Score_Dice' : lesion_wise_dice,
  387. 'LesionWise_Score_HD95' : lesion_wise_hd95
  388. }
  390. final_metrics_dict[label_values[l]] = metrics_dict
  393. #final_lesionwise_metrics_df.to_csv(os.path.split(pred_file)[0] + '/' +
  394. # os.path.split(pred_file)[1].split('.')[0] +
  395. # '_lesionwise_metrics.csv',
  396. # index=False)
  399. results_df = pd.DataFrame(final_metrics_dict).T
  400. results_df['Labels'] = results_df.index
  401. results_df = results_df.reset_index(drop=True)
  402. results_df.insert(0, 'Labels', results_df.pop('Labels'))
  403. results_df.replace(np.inf, 374, inplace=True)
  405. if output:
  406. results_df.to_csv(output, index=False)
  408. return results_df

metrics.py at commit 43c9052, no license · at the source

Overview

Authors: Ethan Truong1, Jordan Houri2,3, Gretchen Hermann1, Vitali Moiseenko1, Jona Hattangadi-Gluth1, Jeffrey Rudie1,4, Aaron B. Simon1,5
ORCID iDs: Aaron B. Simon
  1. Department of Radiation Medicine and Applied Sciences, University of California San Diego, La Jolla, California
  2. Indiana University School of Medicine, Indianapolis, Indiana
  3. Weldon School of Biomedical Engineering, Purdue University, West Lafayette, Indiana
  4. Department of Radiology, Scripps Health, San Diego, California
  5. Department of Radiation Oncology, University of California Irvine, Irvine, California
Institutions: University of California San Diego (United States); Purdue University West Lafayette (United States); Indiana University School of Medicine; Scripps Health (United States); University of California, Irvine (United States)
Journal: Advances in radiation oncology, volume 11, issue 10, article 102092
Dates: received 22 June 2025; accepted 11 May 2026; published online 25 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.adro.2026.102092 · PMID 42733485 · PMCID PMC13571451 · OpenAlex W7162287440
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other condition (population)
Methods: Statistics, Machine learning
Journal subjects: Scientific Article
Topic: Brain Tumor Detection and Classification (Neurology, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 27 references in the paper

Abstract

Purpose: Modern management of brain metastases requires close surveillance with serial magnetic resonance imaging, creating interest in techniques for automated detection. The convolutional neural network (CNN) is currently the dominant approach to automated metastasis detection, and multiple variations of the CNN have been investigated to improve performance. In this work, we looked beyond the impact of network architecture and assessed the impact on performance of providing anatomic contextual information to a CNN during the training period.

Methods and Materials: The nnU-Net, a widely adopted CNN, was selected for this study. The nnU-Net was trained on an institutional data set comprising 301 high-resolution, T1-weighted, contrast-enhanced magnetic resonance images and associated structure labels consisting of both target brain metastases (1111 total) and several organs at risk (OARs) that were labeled in the process of radiosurgery planning. During the training period, the model was presented with either labeled brain metastases (BM) alone or with the complete structure set of metastases and OARs (BM+OAR). The test set contained 100 cases and 421 total metastases.

Results: We found that, by multiple standard performance metrics, the BM+OAR model outperformed the BM model. Median case-wise Dice coefficient for BM was 0.75 (IQR, 0.51-0.86) and for BM+OAR was 0.79 (IQR, 0.58-0.86) (P < .001). Median sensitivity for BM was 1.0 (IQR, 0.71-1.0) and for BM+OAR was 1.0 (IQR, 0.75-1.0) (P < .01). Median positive predictive value for BM was 0.5 (IQR, 0.25-0.74) and for BM+OAR was 0.77 (IQR, 0.50-1.0) (P < .001). Importantly, among lesions scored as “false-positives,” 47/151 detected by BM+OAR could be retrospectively verified to be real tumors, whereas only 22/231 detected by BM could be verified to be real (P < .001).

Conclusions: These findings suggest that providing anatomic contextual information can improve the accuracy of CNN-based automated brain metastasis detection algorithms and open new opportunities for research into the optimization of automated detection approaches for brain metastases.

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

Repositories

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

MIC-DKFZ/nnUNet

License: Apache-2.0
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 202f6baa0adc2ef5f7b615df19cc4da970412cc0, 25 September 2026
Languages: Python (216), Shell (7)
Size: 303 files, 223 scripts
Software Heritage: archived
Found in: the text, “Convolutional neural network”
Holds: README, license file, environment (pyproject.toml, setup.py), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: nnU-Net (125 files), NumPy (73 files), PyTorch (56 files), SimpleITK (10 files), scikit-image (6 files), SciPy (5 files), NiBabel (4 files), pandas (4 files), tifffile (3 files), Matplotlib (2 files), scikit-learn (1 file), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
225 files
At the source: github.com/MIC-DKFZ/nnUNet

data.mendeley.com/preview/jhxrwsct49

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: the link answers
Software Heritage: not checked
Found in: the text, “Convolutional neural network”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
At the source: data.mendeley.com/preview/jhxrwsct49?a=1ded0970-a36f-42c6-99b6-ca4bca6a91aa

rachitsaluja/BraTS-2023-Metrics

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 43c905242b2eecf421d4ab2da7af8ece9777d322, 12 October 2023
Languages: Python (4)
Size: 13 files, 4 scripts
Software Heritage: not archived
Found in: the text, “Model performance evaluation”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (2 files), SciPy (2 files), NiBabel (1 file), pandas (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
5 files
At the source: github.com/rachitsaluja/BraTS-2023-Metrics

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:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 227 scripts, each with its path and the digest of its content;
  • 3 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

No dataset and no data link were found in the paper.

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 2, 28 September 2026

  • Authors: added Aaron B. Simon (0000-0003-4685-2711); removed Aaron B. Simon

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 25 references.

Cite

This paper

Truong, E., Houri, J., Hermann, G., Moiseenko, V., Hattangadi-Gluth, J., Rudie, J., & Simon, A. B. (2026). Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection. Advances in radiation oncology, 11(10), 102092. https://doi.org/10.1016/j.adro.2026.102092

BibTeX

@article{truong2026effect,
author = {Truong, Ethan and Houri, Jordan and Hermann, Gretchen and Moiseenko, Vitali and Hattangadi-Gluth, Jona and Rudie, Jeffrey and Simon, Aaron B.},
title = {{Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection}},
journal = {Advances in radiation oncology},
year = {2026},
month = may,
volume = {11},
number = {10},
pages = {102092},
publisher = {Elsevier},
issn = {2452-1094},
doi = {10.1016/j.adro.2026.102092},
url = {https://doi.org/10.1016/j.adro.2026.102092},
pmid = {42733485},
pmcid = {PMC13571451}
}

RIS

TY - JOUR
AU - Truong, Ethan
AU - Houri, Jordan
AU - Hermann, Gretchen
AU - Moiseenko, Vitali
AU - Hattangadi-Gluth, Jona
AU - Rudie, Jeffrey
AU - Simon, Aaron B.
TI - Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection
T2 - Advances in radiation oncology
J2 - Adv Radiat Oncol
PY - 2026
DA - 2026/05/25
VL - 11
IS - 10
SP - 102092
SN - 2452-1094
PB - Elsevier
DO - 10.1016/j.adro.2026.102092
UR - https://doi.org/10.1016/j.adro.2026.102092
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.adro.2026.102092",
"type": "article-journal",
"title": "Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection",
"container-title": "Advances in radiation oncology",
"author": [
{
"family": "Truong",
"given": "Ethan"
},
{
"family": "Houri",
"given": "Jordan"
},
{
"family": "Hermann",
"given": "Gretchen"
},
{
"family": "Moiseenko",
"given": "Vitali"
},
{
"family": "Hattangadi-Gluth",
"given": "Jona"
},
{
"family": "Rudie",
"given": "Jeffrey"
},
{
"family": "Simon",
"given": "Aaron B."
}
],
"container-title-short": "Adv Radiat Oncol",
"volume": "11",
"issue": "10",
"page": "102092",
"DOI": "10.1016/j.adro.2026.102092",
"PMID": "42733485",
"PMCID": "PMC13571451",
"ISSN": "2452-1094",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.adro.2026.102092",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
25
]
]
}
}

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.1002/hipo.70124 [code]
Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults.
Journal: Hippocampus
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 2 references
[2] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, other condition, 1 reference
[3] doi:10.1007/s12021-026-09817-x [code]
Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA.
Journal: Neuroinformatics
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[4] doi:10.3389/fmed.2026.1875760 [code]
Adaptive multi-stage domain unlearning for white-matter lesion segmentation.
Journal: Frontiers in medicine
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[5] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[6] doi:10.1186/s12880-026-02335-x [code]
Automatic lateral ventricle and choroid plexus segmentation method in infant brain MR images.
Journal: BMC medical imaging
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, 1 reference
[7] doi:10.64898/2026.07.15.26357954 [code]
Portable Ultra-Low Field MRI Deep-Learning Algorithms for White Matter Lesion Segmentation Improve Accuracy and Reflect Clinical Disability in Multiple Sclerosis
Journal: medRxiv (preprint)
In common: nnU-Net, SimpleITK, tifffile, 9 other tools
[8] doi:10.1136/jnnp-2025-335884 [code]
Diffusivity anisotropy signature of slowly expanding lesions predicts progression independent of relapse activity in multiple sclerosis.
Journal: Journal of neurology, neurosurgery, and psychiatry
In common: nnU-Net, SimpleITK, tifffile, 9 other tools
[9] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: nnU-Net, SimpleITK, scikit-image, 8 other tools, other condition
[10] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: nnU-Net, SimpleITK, scikit-image, 8 other tools

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.