OSCR

Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA.

Code ↔ Paper

2 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 2 matches
  1. [1] § Methods › Network Architecture ↔ nndet/arch/heads/classifier.py, lines 295–364 · score 0.68 · cross entropy loss, classification head, bounding box, convolutional, sigmoid, layer
  2. [2] § Methods › Network Architecture ↔ nndet/arch/decoder/base.py, lines 29–104 · score 0.66 · lateral connections, transposed convolutional, decoder, activation, layer, union

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 · 430 lines · 15 KB · no license · 1 match

  1. """
  2. Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
  4. Licensed under the Apache License, Version 2.0 (the "License");
  5. you may not use this file except in compliance with the License.
  6. You may obtain a copy of the License at
  8. http://www.apache.org/licenses/LICENSE-2.0
  10. Unless required by applicable law or agreed to in writing, software
  11. distributed under the License is distributed on an "AS IS" BASIS,
  12. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. See the License for the specific language governing permissions and
  14. limitations under the License.
  15. """
  17. import torch
  18. import math
  19. import torch.nn as nn
  21. from typing import Optional, TypeVar
  22. from torch import Tensor
  23. from abc import abstractmethod
  24. from loguru import logger
  26. from nndet.losses.classification import (
  27. FocalLossWithLogits,
  28. BCEWithLogitsLossOneHot,
  29. CrossEntropyLoss,
  30. )
  32. CONV_TYPES = (nn.Conv2d, nn.Conv3d)
  35. class Classifier(nn.Module):
  36. @abstractmethod
  37. def compute_loss(self, pred_logits: Tensor, targets: Tensor, **kwargs) -> Tensor:
  38. """
  39. Compute classification loss (cross entropy loss)
  41. Args:
  42. pred_logits (Tensor): predicted logits
  43. targets (Tensor): classification targets
  45. Returns:
  46. Tensor: classification loss
  47. """
  48. raise NotImplementedError
  50. @abstractmethod
  51. def box_logits_to_probs(self, box_logits: Tensor) -> Tensor:
  52. """
  53. Convert bounding box logits to probabilities
  55. Args:
  56. box_logits (Tensor): bounding box logits [N, C], C=number of classes
  58. Returns:
  59. Tensor: probabilities
  60. """
  61. raise NotImplementedError
  64. class BaseClassifier(Classifier):
  65. def __init__(self,
  66. conv,
  67. in_channels: int,
  68. internal_channels: int,
  69. num_classes: int,
  70. anchors_per_pos: int,
  71. num_levels: int,
  72. num_convs: int = 3,
  73. add_norm: bool = True,
  74. **kwargs
  75. ):
  76. """
  77. Base class to build classifier heads with typical conv structure
  78. conv(in, internal) -> num_convs x conv(internal, internal) ->
  79. conv(internal, out)
  81. Args:
  82. conv: Convolution modules which handles a single layer
  83. in_channels: number of input channels
  84. internal_channels: number of channels internally used
  85. num_classes: number of foreground classes
  86. anchors_per_pos: number of anchors per position
  87. num_levels: number of decoder levels which are passed through the
  88. classifier
  89. num_convs: number of convolutions
  90. input_conv -> num_convs -> output_convs
  91. add_norm: en-/disable normalization layers in internal layers
  92. kwargs: keyword arguments passed to first and internal convolutions
  94. Notes:
  95. `self.loss` needs to be overwritten in subclasses
  96. `self.logits_convert_fn` needs to be overwritten in subclasses
  97. """
  98. super().__init__()
  99. self.dim = conv.dim
  100. self.num_levels = num_levels
  101. self.num_convs = num_convs
  103. self.num_classes = num_classes
  104. self.anchors_per_pos = anchors_per_pos
  106. self.in_channels = in_channels
  107. self.internal_channels = internal_channels
  109. self.conv_internal = self.build_conv_internal(conv, add_norm=add_norm, **kwargs)
  110. self.conv_out = self.build_conv_out(conv)
  112. self.loss: Optional[nn.Module] = None
  113. self.logits_convert_fn: Optional[nn.Module] = None
  114. self.init_weights()
  116. def build_conv_internal(self, conv, **kwargs):
  117. """
  118. Build internal convolutions
  119. """
  120. _conv_internal = nn.Sequential()
  121. _conv_internal.add_module(
  122. name="c_in",
  123. module=conv(
  124. self.in_channels,
  125. self.internal_channels,
  126. kernel_size=3,
  127. stride=1,
  128. padding=1,
  129. **kwargs,
  130. ))
  131. for i in range(self.num_convs):
  132. _conv_internal.add_module(
  133. name=f"c_internal{i}",
  134. module=conv(
  135. self.internal_channels,
  136. self.internal_channels,
  137. kernel_size=3,
  138. stride=1,
  139. padding=1,
  140. **kwargs,
  141. ))
  142. return _conv_internal
  144. def build_conv_out(self, conv):
  145. """
  146. Build final convolutions
  147. """
  148. out_channels = self.num_classes * self.anchors_per_pos
  149. return conv(
  150. self.internal_channels,
  151. out_channels,
  152. kernel_size=3,
  153. stride=1,
  154. padding=1,
  155. add_norm=False,
  156. add_act=False,
  157. bias=True,
  158. )
  160. def forward(self,
  161. x: torch.Tensor,
  162. level: int,
  163. **kwargs,
  164. ) -> torch.Tensor:
  165. """
  166. Forward input
  168. Args:
  169. x (torch.Tensor): input feature map of size (N x C x Y x X x Z)
  171. Returns:
  172. torch.Tensor: classification logits for each anchor
  173. (N x anchors x num_classes)
  174. """
  175. class_logits = self.conv_out(self.conv_internal(x))
  177. axes = (0, 2, 3, 1) if self.dim == 2 else (0, 2, 3, 4, 1)
  178. class_logits = class_logits.permute(*axes)
  179. class_logits = class_logits.contiguous()
  180. class_logits = class_logits.view(x.size()[0], -1, self.num_classes)
  181. return class_logits
  183. def compute_loss(self, pred_logits: Tensor, targets: Tensor, **kwargs) -> Tensor:
  184. """
  185. Base classifier with cross entropy loss (in general hard negative
  186. example mining should be done before this)
  188. Args:
  189. pred_logits (Tensor): predicted logits
  190. targets (Tensor): classification targets
  192. Returns:
  193. Tensor: classification loss
  194. """
  195. return self.loss(pred_logits, targets.long(), **kwargs)
  197. def box_logits_to_probs(self, box_logits: Tensor) -> Tensor:
  198. """
  199. Convert bounding box logits to probabilities
  201. Args:
  202. box_logits (Tensor): bounding box logits [N, C]
  203. N = number of anchors, C=number of foreground classes
  205. Returns:
  206. Tensor: probabilities
  207. """
  208. return self.logits_convert_fn(box_logits)
  210. def init_weights(self) -> None:
  211. """
  212. Init weights with prior prob
  213. """
  214. if self.prior_prob is not None:
  215. logger.info(f"Init classifier weights: prior prob {self.prior_prob}")
  216. for layer in self.modules():
  217. if isinstance(layer, CONV_TYPES):
  218. torch.nn.init.normal_(layer.weight, mean=0, std=0.01)
  219. if layer.bias is not None:
  220. torch.nn.init.constant_(layer.bias, 0)
  222. # Use prior in model initialization to improve stability
  223. bias_value = -math.log((1 - self.prior_prob) / self.prior_prob)
  224. for layer in self.conv_out.modules():
  225. if isinstance(layer, CONV_TYPES):
  226. torch.nn.init.constant_(layer.bias, bias_value)
  227. else:
  228. logger.info("Init classifier weights: conv default")
  231. class BCECLassifier(BaseClassifier):
  232. def __init__(self,
  233. conv,
  234. in_channels: int,
  235. internal_channels: int,
  236. num_classes: int,
  237. anchors_per_pos: int,
  238. num_levels: int,
  239. num_convs: int = 3,
  240. add_norm: bool = True,
  241. prior_prob: Optional[float] = None,
  242. weight: Optional[Tensor] = None,
  243. reduction: str = "mean",
  244. smoothing: float = 0.0,
  245. loss_weight: float = 1.,
  246. **kwargs
  247. ):
  248. """
  249. Classifier Head with sigmoid based BCE loss computation and prio
  250. prob weight init
  251. conv(in, internal) -> num_convs x conv(internal, internal) ->
  252. conv(internal, out)
  254. Args:
  255. conv: Convolution modules which handles a single layer
  256. in_channels: number of input channels
  257. internal_channels: number of channels internally used
  258. num_classes: number of foreground classes
  259. anchors_per_pos: number of anchors per position
  260. num_levels: number of decoder levels which are passed through the
  261. classifier
  262. num_convs: number of convolutions
  263. input_conv -> num_convs -> output_convs
  264. add_norm: en-/disable normalization layers in internal layers
  265. prior_prob: initialize final conv with given prior probability
  266. weight: weight in BCEWithLogitsLoss (see pytorch for more info)
  267. reduction: reduction to apply to loss. 'sum' | 'mean' | 'none'
  268. smoothing: label smoothing
  269. loss_weight: scalar to balance multiple losses
  270. kwargs: keyword arguments passed to first and internal convolutions
  271. """
  272. self.prior_prob = prior_prob
  273. super().__init__(
  274. conv=conv,
  275. in_channels=in_channels,
  276. num_convs=num_convs,
  277. add_norm=add_norm,
  278. internal_channels=internal_channels,
  279. num_classes=num_classes,
  280. anchors_per_pos=anchors_per_pos,
  281. num_levels=num_levels,
  282. **kwargs,
  283. )
  285. self.loss = BCEWithLogitsLossOneHot(
  286. num_classes=num_classes,
  287. weight=weight,
  288. reduction=reduction,
  289. smoothing=smoothing,
  290. loss_weight=loss_weight,
  291. )
  292. self.logits_convert_fn = nn.Sigmoid()
  295. class CEClassifier(BaseClassifier):
  296. def __init__(self,
  297. conv,
  298. in_channels: int,
  299. internal_channels: int,
  300. num_classes: int,
  301. anchors_per_pos: int,
  302. num_levels: int,
  303. num_convs: int = 3,
  304. add_norm: bool = True,
  305. prior_prob: Optional[float] = None,
  306. weight: Optional[Tensor] = None,
  307. reduction: str = "mean",
  308. loss_weight: float = 1.,
  309. **kwargs
  310. ):
  311. """
  312. Classifier Head with sigmoid based BCE loss computation and prio
  313. prob weight init
  314. conv(in, internal) -> num_convs x conv(internal, internal) ->
  315. conv(internal, out)
  317. Args:
  318. conv: Convolution modules which handles a single layer
  319. in_channels: number of input channels
  320. internal_channels: number of channels internally used
  321. num_classes: number of foreground classes
  322. anchors_per_pos: number of anchors per position
  323. num_levels: number of decoder levels which are passed through the
  324. classifier
  325. num_convs: number of convolutions
  326. input_conv -> num_convs -> output_convs
  327. add_norm: en-/disable normalization layers in internal layers
  328. prior_prob: initialize final conv with given prior probability
  329. weight: weight in cross entrpoy loss (see pytorch for more info)
  330. reduction: reduction to apply to loss. 'sum' | 'mean' | 'none'
  331. loss_weight: scalar to balance multiple losses
  332. kwargs: keyword arguments passed to first and internal convolutions
  333. """
  334. self.prior_prob = prior_prob
  335. super().__init__(
  336. conv=conv,
  337. in_channels=in_channels,
  338. num_convs=num_convs,
  339. add_norm=add_norm,
  340. internal_channels=internal_channels,
  341. num_classes=num_classes + 1, # add one channel for background
  342. anchors_per_pos=anchors_per_pos,
  343. num_levels=num_levels,
  344. **kwargs,
  345. )
  347. self.loss = CrossEntropyLoss(
  348. weight=weight,
  349. reduction=reduction,
  350. loss_weight=loss_weight,
  351. )
  352. self.logits_convert_fn = nn.Softmax(dim=1)
  354. def box_logits_to_probs(self, box_logits: Tensor) -> Tensor:
  355. """
  356. Convert bounding box logits to probabilities
  358. Args:
  359. box_logits (Tensor): bounding box logits [N, C], C=number of classes
  361. Returns:
  362. Tensor: probabilities
  363. """
  364. return self.logits_convert_fn(box_logits)[:, 1:] # remove background predictions
  367. class FocalClassifier(BaseClassifier):
  368. def __init__(self,
  369. conv,
  370. in_channels: int,
  371. internal_channels: int,
  372. num_classes: int,
  373. anchors_per_pos: int,
  374. num_levels: int,
  375. num_convs: int = 3,
  376. add_norm: bool = True,
  377. prior_prob: Optional[float] = None,
  378. gamma: float = 2,
  379. alpha: float = -1,
  380. reduction: str = "sum",
  381. loss_weight: float = 1.,
  382. **kwargs
  383. ):
  384. """
  385. Classifier Head with sigmoid based BCE loss computation and
  386. prio prob weight init
  387. conv(in, internal) -> num_convs x conv(internal, internal) ->
  388. conv(internal, out)
  390. Args:
  391. conv: Convolution modules which handles a single layer
  392. in_channels: number of input channels
  393. internal_channels: number of channels internally used
  394. num_classes: number of foreground classes
  395. anchors_per_pos: number of anchors per position
  396. num_levels: number of decoder levels which are passed through the
  397. classifier
  398. num_convs: number of convolutions
  399. input_conv -> num_convs -> output_convs
  400. add_norm: en-/disable normalization layers in internal layers
  401. prior_prob: initialize final conv with given prior probability
  402. gamma: focal loss gamma
  403. alpha: focal loss alpha
  404. reduction: reduction to apply to loss. 'sum' | 'mean' | 'none'
  405. loss_weight: scalar to balance multiple losses
  406. kwargs: keyword arguments passed to first and internal convolutions
  407. """
  408. self.prior_prob = prior_prob
  409. super().__init__(
  410. conv=conv,
  411. in_channels=in_channels,
  412. num_convs=num_convs,
  413. add_norm=add_norm,
  414. internal_channels=internal_channels,
  415. num_classes=num_classes,
  416. anchors_per_pos=anchors_per_pos,
  417. num_levels=num_levels,
  418. **kwargs,
  419. )
  421. self.loss = FocalLossWithLogits(
  422. gamma=gamma,
  423. alpha=alpha,
  424. reduction=reduction,
  425. loss_weight=loss_weight,
  426. )
  427. self.logits_convert_fn = nn.Sigmoid()
  430. ClassifierType = TypeVar('ClassifierType', bound=Classifier)

classifier.py at commit 97a58f3, no license · at the source

Overview

Authors: Valeriia Abramova1, Arnau Oliver1, Uma M Lal-Trehan Estrada1, Rachika E Hamadache1, Paola Martínez Arias1, Jordi Freixenet1, Mikel Terceño2, Yolanda Silva2, Xavier Lladó1
  1. Computer Vision and Robotics Institute, University of Girona, Girona, Catalonia Spain
  2. Department of Neurology, Hospital Universitari Dr Josep Trueta - Institut d’Investigació Biomèdica de Girona, Girona, Catalonia Spain
Institutions: Universitat de Girona (Spain); Institut d'Investigació Biomèdica de Girona (Spain); Hospital Universitari de Girona Doctor Josep Trueta (Spain)
Journal: Neuroinformatics, volume 24, issue 4, article 62
Dates: received 16 January 2026; accepted 2 September 2026; published online 16 September 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1007/s12021-026-09817-x · PMID 42747736 · PMCID PMC13582341 · OpenAlex W7213233328
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), human (organism)
Methods: Connectivity, Machine learning, fMRI & imaging
Keywords: Computed tomography angiography, Large vessel occlusion, Circle of willis, nnDetection
MeSH: Brain*, Cerebral Angiography*, Circle of Willis*, Computed Tomography Angiography*, Humans (* major topic)
Topic: Acute Ischemic Stroke Management (Epidemiology, Medicine), according to OpenAlex
Funding: Nvidia; Universitat de Girona (IFUdG2024); Ministerio de Ciencia, Innovación y Universidades (PID2023, PID2023-146187OB-I00, PRE2021-099121, DPI2020-114769RB-I00); Fundació Institució Catalana de Recerca i Estudis Avançats (ICREA); European Regional Development Fund
Citations: not cited yet (Europe PMC); 32 references in the paper

Abstract

Large vessel occlusions (LVOs) are blockages in the brain’s major arteries that can cause severe neurological damage. Rapid and accurate detection using computed tomography angiography (CTA) is critical for timely stroke treatment. Here, we present a fully automated approach that detects LVOs and classifies the affected vessel simultaneously. Our method incorporates a spatial prior by using Circle of Willis (CoW) segmentation as additional input, guiding the model to anatomically relevant regions. We evaluated the two strategies, the global approach using the full CTA volume, and the local one focused on CoW regions. Both achieved high performance. Detection sensitivity was 0.97 at 0.20 false positives per image for the global approach, and 0.97 at 0.13 false positives for the local approach. Classification accuracy reached 94% and 91% for global and local strategies, respectively. Importantly, the local approach was 3.3× faster, offering a computationally efficient solution, a critical advantage in acute stroke care, where every minute impacts patient outcomes.

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 2 matches between paragraphs and lines of code.

MIC-DKFZ/nnDetection

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 97a58f3110b71caf1b4bcc1851e67cf11e987fc5, 27 October 2025
Languages: Python (161), C++ (2), C/C++ (1), CUDA (1), Shell (1)
Size: 223 files, 166 scripts
Software Heritage: not archived
Found in: “Information Sharing Statement”
Holds: README, license file, environment (Dockerfile, requirements.txt, setup.cfg, setup.py, projects/Task019_ADAM/submission/Dockerfile), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: PyTorch (56 files), NumPy (53 files), SimpleITK (15 files), pandas (6 files), scikit-learn (6 files), PyTorch Lightning (5 files), Matplotlib (5 files), nnU-Net (5 files), SciPy (5 files), scikit-image (2 files), seaborn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
167 files
At the source: github.com/MIC-DKFZ/nnDetection

NIC-VICOROB/CoW-multiclass-segmentation-TopCoW24

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: e47cc66e9211d3dab8400ffac599c3523d0f08d9, 3 February 2026
Languages: Python (552), Shell (16), Jupyter (4)
Size: 705 files, 572 scripts
Software Heritage: not archived
Found in: “Information Sharing Statement”
Holds: README, environment (nnUNet/pyproject.toml, nnUNet/setup.py, algo_submission/task-1-seg/Dockerfile, algo_submission/task-1-seg/requirements.txt, algo_submission/task-2-box/Dockerfile, algo_submission/task-2-box/requirements.txt), tests, documentation, 4 notebooks
Not found: license file, CITATION.cff, continuous integration
Tools: nnU-Net (312 files), NumPy (221 files), PyTorch (166 files), SimpleITK (25 files), scikit-image (20 files), SciPy (18 files), NiBabel (12 files), Matplotlib (10 files), pandas (10 files), tifffile (6 files), seaborn (4 files), scikit-learn (3 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
573 files
At the source: github.com/NIC-VICOROB/CoW-multiclass-segmentation-TopCoW24

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:

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

Data Availability

The in-house dataset used for developing of the algorithm in the current study is not publicly available due to the confidentiality policy and institutional patient privacy regulation. The CODEC-IV dataset can be obtained in accordance with the original data provider’s and license terms.

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

  • Publisher: n/a → Springer Science+Business Media
  • Funding: added Nvidia; Universitat de Girona: IFUdG2024; Ministerio de Ciencia, Innovación y Universidades: PID2023, PID2023-146187OB-I00, PRE2021-099121, DPI2020-114769RB-I00; Institució Catalana de Recerca i Estudis Avançats; Education, Audiovisual and Culture Executive Agency

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 4 keywords, 5 MeSH terms, 30 references.

Cite

This paper

Abramova, V., Oliver, A., Lal-Trehan Estrada, U. M., Hamadache, R. E., Martínez Arias, P., Freixenet, J., Terceño, M., Silva, Y., & Lladó, X. (2026). Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA. Neuroinformatics, 24(4), 62. https://doi.org/10.1007/s12021-026-09817-x

BibTeX

@article{abramova2026circle,
author = {Abramova, Valeriia and Oliver, Arnau and Lal-Trehan Estrada, Uma M and Hamadache, Rachika E and Martínez Arias, Paola and Freixenet, Jordi and Terceño, Mikel and Silva, Yolanda and Lladó, Xavier},
title = {{Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA}},
journal = {Neuroinformatics},
year = {2026},
month = sep,
volume = {24},
number = {4},
pages = {62},
publisher = {Springer Science+Business Media},
issn = {1539-2791},
doi = {10.1007/s12021-026-09817-x},
url = {https://doi.org/10.1007/s12021-026-09817-x},
pmid = {42747736},
pmcid = {PMC13582341}
}

RIS

TY - JOUR
AU - Abramova, Valeriia
AU - Oliver, Arnau
AU - Lal-Trehan Estrada, Uma M
AU - Hamadache, Rachika E
AU - Martínez Arias, Paola
AU - Freixenet, Jordi
AU - Terceño, Mikel
AU - Silva, Yolanda
AU - Lladó, Xavier
TI - Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA
T2 - Neuroinformatics
J2 - Neuroinformatics
PY - 2026
DA - 2026/09/16
VL - 24
IS - 4
SP - 62
SN - 1539-2791
PB - Springer Science+Business Media
DO - 10.1007/s12021-026-09817-x
UR - https://doi.org/10.1007/s12021-026-09817-x
LA - en
ER -

CSL-JSON

{
"id": "10.1007/s12021-026-09817-x",
"type": "article-journal",
"title": "Circle of Willis-Guided Localization for Simultaneous Detection and Classification of Large Vessel Occlusions in Brain CTA",
"container-title": "Neuroinformatics",
"author": [
{
"family": "Abramova",
"given": "Valeriia"
},
{
"family": "Oliver",
"given": "Arnau"
},
{
"family": "Lal-Trehan Estrada",
"given": "Uma M"
},
{
"family": "Hamadache",
"given": "Rachika E"
},
{
"family": "Martínez Arias",
"given": "Paola"
},
{
"family": "Freixenet",
"given": "Jordi"
},
{
"family": "Terceño",
"given": "Mikel"
},
{
"family": "Silva",
"given": "Yolanda"
},
{
"family": "Lladó",
"given": "Xavier"
}
],
"container-title-short": "Neuroinformatics",
"volume": "24",
"issue": "4",
"page": "62",
"DOI": "10.1007/s12021-026-09817-x",
"PMID": "42747736",
"PMCID": "PMC13582341",
"ISSN": "1539-2791",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1007/s12021-026-09817-x",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
16
]
]
}
}

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, 1 reference
[2] 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
[3] 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, 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.1016/j.adro.2026.102092 [code]
Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.
Journal: Advances in radiation oncology
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.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, other
[10] 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

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.