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.

2 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 3 matches
  1. [1] § Methods and Materials › Model performance evaluation ↔ metrics.py, lines 113 to 254 · score 0.81 · ground truth, GT lesion, positive lesions, predicted segmentations, score, FP · block oscr:b:MQXJNE3EQRCFY-T · Report a mismatch
  2. [2] § Methods and Materials › Model performance evaluation ↔ metrics.py, lines 113 to 254 · score 0.66 · TP lesion, FN lesion, Hausdorff, FP, BraTS, HD95 · block oscr:b:MQXJNE3EQRCFY-T · Report a mismatch
  3. [3] § Methods and Materials › Convolutional neural network ↔ nnunetv2/training/nnUNetTrainer/nnUNetTrainer.py, lines 168 to 229 · score 0.58 · deep learning, network architecture, hyperparameter, image segmentation, weights, training · block oscr:b:2YAG17A6P05C7-3 · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: 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
  10. def dice(im1, im2):
  11. """
  12. Computes Dice score for two images
  13. Parameters
  14. ==========
  15. im1: Numpy Array/Matrix; Predicted segmentation in matrix form
  16. im2: Numpy Array/Matrix; Ground truth segmentation in matrix form
  17. Output
  18. ======
  19. dice_score: Dice score between two images
  20. """
  21. im1 = np.asarray(im1).astype(bool)
  22. im2 = np.asarray(im2).astype(bool)
  23. if im1.shape != im2.shape:
  24. raise ValueError("Shape mismatch: im1 and im2 must have the same shape.")
  25. # Compute Dice coefficient
  26. intersection = np.logical_and(im1, im2)
  27. return 2. * (intersection.sum()) / (im1.sum() + im2.sum())
  28. def get_TissueWiseSeg(prediction_matrix, gt_matrix, tissue_type):
  29. """
  30. Converts the segmentatations to isolate tissue types
  31. Parameters
  32. ==========
  33. prediction_matrix: Numpy Array/Matrix; Predicted segmentation in matrix form
  34. gt_matrix: Numpy Array/Matrix; Ground truth segmentation in matrix form
  35. tissue_type: str; Can be WT, ET or TC
  36. Output
  37. ======
  38. prediction_matrix: Numpy Array/Matrix; Predicted segmentation in matrix form with
  39. just tissue type mentioned
  40. gt_matrix: Numpy Array/Matrix; Ground truth segmentation in matrix form with just
  41. tissue type mentioned
  42. """
  43. if tissue_type == 'WT':
  44. np.place(prediction_matrix, (prediction_matrix != 1) & (prediction_matrix != 2) & (prediction_matrix != 3), 0)
  45. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  46. np.place(gt_matrix, (gt_matrix != 1) & (gt_matrix != 2) & (gt_matrix != 3), 0)
  47. np.place(gt_matrix, (gt_matrix > 0), 1)
  48. elif tissue_type == 'TC':
  49. np.place(prediction_matrix, (prediction_matrix != 1) & (prediction_matrix != 3), 0)
  50. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  51. np.place(gt_matrix, (gt_matrix != 1) & (gt_matrix != 3), 0)
  52. np.place(gt_matrix, (gt_matrix > 0), 1)
  53. elif tissue_type == 'ET':
  54. np.place(prediction_matrix, (prediction_matrix != 3), 0)
  55. np.place(prediction_matrix, (prediction_matrix > 0), 1)
  56. np.place(gt_matrix, (gt_matrix != 3), 0)
  57. np.place(gt_matrix, (gt_matrix > 0), 1)
  58. return prediction_matrix, gt_matrix
  59. def get_GTseg_combinedByDilation(gt_dilated_cc_mat, gt_label_cc):
  60. """
  61. Computes the Corrected Connected Components after combing lesions
  62. together with respect to their dilation extent
  63. Parameters
  64. ==========
  65. gt_dilated_cc_mat: Numpy Array/Matrix; Ground Truth Dilated Segmentation
  66. after CC Analysis
  67. gt_label_cc: Numpy Array/Matrix; Ground Truth Segmentation after
  68. CC Analysis
  69. Output
  70. ======
  71. gt_seg_combinedByDilation_mat: Numpy Array/Matrix; Ground Truth
  72. Segmentation after CC Analysis and
  73. combining lesions
  74. """
  75. gt_seg_combinedByDilation_mat = np.zeros_like(gt_dilated_cc_mat)
  76. for comp in range(np.max(gt_dilated_cc_mat)):
  77. comp += 1
  78. gt_d_tmp = np.zeros_like(gt_dilated_cc_mat)
  79. gt_d_tmp[gt_dilated_cc_mat == comp] = 1
  80. gt_d_tmp = (gt_label_cc*gt_d_tmp)
  81. np.place(gt_d_tmp, gt_d_tmp > 0, comp)
  82. gt_seg_combinedByDilation_mat += gt_d_tmp
  83. return gt_seg_combinedByDilation_mat
  84. def get_LesionWiseScores(prediction_seg, gt_seg, label_value, dil_factor):
  85. """
  86. Computes the Lesion-wise scores for pair of prediction and ground truth
  87. segmentations
  88. Parameters
  89. ==========
  90. prediction_seg: str; location of the prediction segmentation
  91. gt_label_cc: str; location of the gt segmentation
  92. label_value: str; Can be WT, ET or TC
  93. dil_factor: int; Used to perform dilation
  94. Output
  95. ======
  96. tp: Number of TP lesions WRT prediction segmentation
  97. fn: Number of FN lesions WRT prediction segmentation
  98. fp: Number of FP lesions WRT prediction segmentation
  99. gt_tp: Number of Ground Truth TP lesions WRT prediction segmentation
  100. metric_pairs: list; All the lesion-wise metrics
  101. full_dice: Dice Score of the pair of segmentations
  102. full_gt_vol: Total Ground Truth Segmenatation Volume
  103. full_pred_vol: Total Prediction Segmentation Volume
  104. """
  105. ## Get Prediction and GT segs matrix files
  106. pred_nii = nib.load(prediction_seg)
  107. gt_nii = nib.load(gt_seg)
  108. pred_mat = pred_nii.get_fdata()
  109. gt_mat = gt_nii.get_fdata()
  110. ## Get Spacing to computes volumes
  111. ## Brats Assumes all spacing is 1x1x1mm3
  112. sx, sy, sz = pred_nii.header.get_zooms()
  113. ## Get the prediction and GT matrix based on
  114. ## WT, TC, ET
  115. pred_mat, gt_mat = get_TissueWiseSeg(
  116. prediction_matrix = pred_mat,
  117. gt_matrix = gt_mat,
  118. tissue_type = label_value
  119. )
  120. ## Get Dice score for the full image
  121. if np.all(gt_mat==0) and np.all(pred_mat==0):
  122. full_dice = 1.0
  123. else:
  124. full_dice = dice(
  125. pred_mat,
  126. gt_mat
  127. )
  128. ## Get HD95 sccre for the full image
  129. if np.all(gt_mat==0) and np.all(pred_mat==0):
  130. full_hd95 = 0.0
  131. else:
  132. full_sd = surface_distance.compute_surface_distances(gt_mat.astype(int),
  133. pred_mat.astype(int),
  134. (sx,sy,sz))
  135. full_hd95 = surface_distance.compute_robust_hausdorff(full_sd, 95)
  136. ## Get Sensitivity and Specificity
  137. full_sens, full_specs = get_sensitivity_and_specificity(result_array = pred_mat,
  138. target_array = gt_mat)
  139. ## Get GT Volume and Pred Volume for the full image
  140. full_gt_vol = np.sum(gt_mat)*sx*sy*sz
  141. full_pred_vol = np.sum(pred_mat)*sx*sy*sz
  142. ## Performing Dilation and CC analysis
  143. dilation_struct = scipy.ndimage.generate_binary_structure(3, 2)
  144. gt_mat_cc = cc3d.connected_components(gt_mat, connectivity=26)
  145. pred_mat_cc = cc3d.connected_components(pred_mat, connectivity=26)
  146. gt_mat_dilation = scipy.ndimage.binary_dilation(gt_mat, structure = dilation_struct, iterations = dil_factor)
  147. gt_mat_dilation_cc = cc3d.connected_components(gt_mat_dilation, connectivity=26)
  148. gt_mat_combinedByDilation = get_GTseg_combinedByDilation(
  149. gt_dilated_cc_mat = gt_mat_dilation_cc,
  150. gt_label_cc = gt_mat_cc
  151. )
  152. ## Performing the Lesion-By-Lesion Comparison
  153. gt_label_cc = gt_mat_combinedByDilation
  154. pred_label_cc = pred_mat_cc
  155. gt_tp = []
  156. tp = []
  157. fn = []
  158. fp = []
  159. metric_pairs = []
  160. for gtcomp in range(np.max(gt_label_cc)):
  161. gtcomp += 1
  162. ## Extracting current lesion
  163. gt_tmp = np.zeros_like(gt_label_cc)
  164. gt_tmp[gt_label_cc == gtcomp] = 1
  165. ## Extracting ROI GT lesion component
  166. gt_tmp_dilation = scipy.ndimage.binary_dilation(gt_tmp, structure = dilation_struct, iterations = dil_factor)
  167. # Volume of lesion
  168. gt_vol = np.sum(gt_tmp)*sx*sy*sz
  169. ## Extracting Predicted true positive lesions
  170. pred_tmp = np.copy(pred_label_cc)
  171. #pred_tmp = pred_tmp*gt_tmp
  172. pred_tmp = pred_tmp*gt_tmp_dilation
  173. intersecting_cc = np.unique(pred_tmp)
  174. intersecting_cc = intersecting_cc[intersecting_cc != 0]
  175. for cc in intersecting_cc:
  176. tp.append(cc)
  177. ## Isolating Predited Lesions to calulcate Metrics
  178. pred_tmp = np.copy(pred_label_cc)
  179. pred_tmp[np.isin(pred_tmp,intersecting_cc,invert=True)] = 0
  180. pred_tmp[np.isin(pred_tmp,intersecting_cc)] = 1
  181. ## Calculating Lesion-wise Dice and HD95
  182. dice_score = dice(pred_tmp, gt_tmp)
  183. surface_distances = surface_distance.compute_surface_distances(gt_tmp, pred_tmp, (sx,sy,sz))
  184. hd = surface_distance.compute_robust_hausdorff(surface_distances, 95)
  185. metric_pairs.append((intersecting_cc,
  186. gtcomp, gt_vol, dice_score, hd))
  187. ## Extracting Number of TP/FP/FN and other data
  188. if len(intersecting_cc) > 0:
  189. gt_tp.append(gtcomp)
  190. else:
  191. fn.append(gtcomp)
  192. fp = np.unique(
  193. pred_label_cc[np.isin(
  194. pred_label_cc,tp+[0],invert=True)])
  195. return tp, fn, fp, gt_tp, metric_pairs, full_dice, full_hd95, full_gt_vol, full_pred_vol, full_sens, full_specs
  196. def get_sensitivity_and_specificity(result_array, target_array):
  197. """
  198. This function is extracted from GaNDLF from mlcommons
  199. You can find the documentation here -
  200. https://github.com/mlcommons/GaNDLF/blob/master/GANDLF/metrics/segmentation.py#L196
  201. """
  202. iC = np.sum(result_array)
  203. rC = np.sum(target_array)
  204. overlap = np.where((result_array == target_array), 1, 0)
  205. # Where they agree are both equal to that value
  206. TP = overlap[result_array == 1].sum()
  207. FP = iC - TP
  208. FN = rC - TP
  209. TN = np.count_nonzero((result_array != 1) & (target_array != 1))
  210. Sens = 1.0 * TP / (TP + FN + sys.float_info.min)
  211. Spec = 1.0 * TN / (TN + FP + sys.float_info.min)
  212. # Make Changes if both input and reference are 0 for the tissue type
  213. if (iC == 0) and (rC == 0):
  214. Sens = 1.0
  215. return Sens, Spec
  216. def get_LesionWiseResults(pred_file, gt_file, challenge_name, output=None):
  217. """
  218. Computes the Lesion-wise scores for pair of prediction and ground truth
  219. segmentations
  220. Parameters
  221. ==========
  222. pred_file: str; location of the prediction segmentation
  223. gt_file: str; location of the gt segmentation
  224. challenge_name: str; name of the challenge for parameters
  225. Output
  226. ======
  227. Saves the performance metrics as CSVs
  228. results_df: pd.DataFrame; lesion-wise results with other metrics
  229. """
  230. ## Dilation and Threshold Parameters
  231. if challenge_name == 'BraTS-GLI':
  232. dilation_factor = 3
  233. lesion_volume_thresh = 50
  234. elif challenge_name == 'BraTS-SSA':
  235. dilation_factor = 3
  236. lesion_volume_thresh = 50
  237. elif challenge_name == 'BraTS-MEN':
  238. dilation_factor = 1
  239. lesion_volume_thresh = 50
  240. elif challenge_name == 'BraTS-PED':
  241. dilation_factor = 3
  242. lesion_volume_thresh = 50
  243. elif challenge_name == 'BraTS-MET':
  244. dilation_factor = 1
  245. lesion_volume_thresh = 2
  246. final_lesionwise_metrics_df = pd.DataFrame()
  247. final_metrics_dict = dict()
  248. label_values = ['WT', 'TC', 'ET']
  249. for l in range(len(label_values)):
  250. tp, fn, fp, gt_tp, metric_pairs, full_dice, full_hd95, full_gt_vol, full_pred_vol, full_sens, full_specs = get_LesionWiseScores(
  251. prediction_seg = pred_file,
  252. gt_seg = gt_file,
  253. label_value = label_values[l],
  254. dil_factor = dilation_factor
  255. )
  256. metric_df = pd.DataFrame(
  257. metric_pairs, columns=['predicted_lesion_numbers', 'gt_lesion_numbers',
  258. 'gt_lesion_vol', 'dice_lesionwise', 'hd95_lesionwise']
  259. ).sort_values(by = ['gt_lesion_numbers'], ascending=True).reset_index(drop = True)
  260. metric_df['_len'] = metric_df['predicted_lesion_numbers'].map(len)
  261. ## Removing <= 50 lesions from analysis
  262. fn_sub = (metric_df[(metric_df['_len'] == 0) &
  263. (metric_df['gt_lesion_vol'] <= lesion_volume_thresh)
  264. ]).shape[0]
  265. gt_tp_sub = (metric_df[(metric_df['_len'] != 0) &
  266. (metric_df['gt_lesion_vol'] <= lesion_volume_thresh)
  267. ]).shape[0]
  268. metric_df['Label'] = [label_values[l]]*len(metric_df)
  269. metric_df = metric_df.replace(np.inf, 374)
  270. final_lesionwise_metrics_df = final_lesionwise_metrics_df.append(metric_df)
  271. metric_df_thresh = metric_df[metric_df['gt_lesion_vol'] > lesion_volume_thresh]
  272. try:
  273. lesion_wise_dice = np.sum(metric_df_thresh['dice_lesionwise'])/(len(metric_df_thresh) + len(fp))
  274. except:
  275. lesion_wise_dice = np.nan
  276. try:
  277. lesion_wise_hd95 = (np.sum(metric_df_thresh['hd95_lesionwise']) + len(fp)*374)/(len(metric_df_thresh) + len(fp))
  278. except:
  279. lesion_wise_hd95 = np.nan
  280. if math.isnan(lesion_wise_dice):
  281. lesion_wise_dice = 1
  282. if math.isnan(lesion_wise_hd95):
  283. lesion_wise_hd95 = 0
  284. metrics_dict = {
  285. 'Num_TP' : len(gt_tp) - gt_tp_sub, # GT_TP
  286. #'Num_TP' : len(tp),
  287. 'Num_FP' : len(fp),
  288. 'Num_FN' : len(fn) - fn_sub,
  289. 'Sensitivity': full_sens,
  290. 'Specificity': full_specs,
  291. 'Legacy_Dice' : full_dice,
  292. 'Legacy_HD95' : full_hd95,
  293. 'GT_Complete_Volume' : full_gt_vol,
  294. 'LesionWise_Score_Dice' : lesion_wise_dice,
  295. 'LesionWise_Score_HD95' : lesion_wise_hd95
  296. }
  297. final_metrics_dict[label_values[l]] = metrics_dict
  298. #final_lesionwise_metrics_df.to_csv(os.path.split(pred_file)[0] + '/' +
  299. # os.path.split(pred_file)[1].split('.')[0] +
  300. # '_lesionwise_metrics.csv',
  301. # index=False)
  302. results_df = pd.DataFrame(final_metrics_dict).T
  303. results_df['Labels'] = results_df.index
  304. results_df = results_df.reset_index(drop=True)
  305. results_df.insert(0, 'Labels', results_df.pop('Labels'))
  306. results_df.replace(np.inf, 374, inplace=True)
  307. if output:
  308. results_df.to_csv(output, index=False)
  309. 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 (United States); 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 (how the code is found and verified)
Categories: other condition (population)
Methods: Statistics, Machine learning
Journal subjects: Scientific Article
Topic: Brain Tumor Detection and Classification (Computer Vision and Pattern Recognition, Computer Science), 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 27 October 2026
Evidence: files inventoried
Commit: 1489d746e084459581ff20382c1241d8cc2eb258, 22 October 2026
Languages: Python (228), Shell (7)
Size: 315 files, 235 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 (136 files), NumPy (82 files), PyTorch (62 files), SimpleITK (15 files), scikit-image (7 files), SciPy (7 files), NiBabel (5 files), pandas (4 files), tifffile (4 files), Matplotlib (2 files), Pillow (1 file), pydicom (1 file), scikit-learn (1 file), seaborn (1 file)
Availability: 2 checks, the latest on 27 October 2026: the link answers
  • 27 October 2026: the link answers
  • 26 September 2026: the link answers
237 files

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)

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

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;
  • 239 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.1186/s41747-025-00554-5 [code]
Enhancing deep learning methods for brain metastasis detection through cross-technique annotations on SPACE MRI.
Journal: European radiology experimental
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 5 references
[2] doi:10.1093/noajnl/vdac138 [code]
Automated detection and quantification of brain metastases on clinical MRI data using artificial neural networks.
Journal: Neuro-oncology advances
In common: nnU-Net, SimpleITK, PyTorch, 2 other tools, other condition, 11 references
[3] doi:10.1186/s40644-024-00669-9 [code]
Deep learning-based metastasis detection in patients with lung cancer to enhance reproducibility and reduce workload in brain metastasis screening with MRI: a multi-center study.
Journal: Cancer imaging : the official publication of the International Cancer Imaging Society
In common: nnU-Net, SimpleITK, scikit-image, 6 other tools, other condition, 6 references
[4] 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, pydicom, SimpleITK, 11 other tools, 2 references
[5] doi:10.1371/journal.pone.0323398 [code]
Ratio maps of T1w/T2w MRI signal intensity do not improve deep-learning segmentation of pediatric brain tumors.
Journal: PloS one
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference
[6] doi:10.1038/s41597-024-03073-x [code]
Brain tumor segmentation using synthetic MR images - A comparison of GANs and diffusion models.
Journal: Scientific data
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference
[7] doi:10.1007/s00701-024-05973-8 [code]
NnU-Net versus mesh growing algorithm as a tool for the robust and timely segmentation of neurosurgical 3D images in contrast-enhanced T1 MRI scans.
Journal: Acta neurochirurgica
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference
[8] doi:10.1016/j.isci.2024.109023 [code]
Deep learning aided preoperative diagnosis of primary central nervous system lymphoma.
Journal: iScience
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference
[9] doi:10.3389/fonc.2023.1143688 [code]
Deep-learning and conventional radiomics to predict <i>IDH</i> genotyping status based on magnetic resonance imaging data in adult diffuse glioma.
Journal: Frontiers in oncology
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference
[10] doi:10.1093/braincomms/fcad118 [code]
Brain tumour segmentation with incomplete imaging data.
Journal: Brain communications
In common: nnU-Net, pydicom, SimpleITK, 11 other tools, other condition, 1 reference

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092.svg)](https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092.svg
   :target: https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092"><img src="https://openscicode.org/badge/doi/10.1016/j.adro.2026.102092.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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