OSCR

An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.

Code ↔ Paper

13 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 13 matches
  1. [1] § Materials and methods › Pipeline overview ↔ head_seg/entire_pipeline.py, lines 1–30 · score 0.77 · end pipeline, extraaxial CSF, brain segmentation, brain parenchyma, head circumference, biometry
  2. [2] § Experimental results and discussion › Failure case analysis ↔ head_seg/entire_pipeline.py, lines 1–30 · score 0.71 · automated fetal brain, entire pipeline, SSFP MRI, head circumference, Tri Attention, biometry
  3. [3] § Materials and methods › Proposed model architecture ↔ brain_seg/triatt.py, lines 174–214 · score 0.64 · SE block, decoder blocks, encoder block, deep supervision, bottleneck, ECA
  4. [4] § Materials and methods › Proposed model architecture ↔ head_seg/triatt.py, lines 174–214 · score 0.64 · SE block, decoder blocks, encoder block, deep supervision, bottleneck, ECA
  5. [5] § Materials and methods › Implementation, experiments and evaluation metrics ↔ nnUNet-master/nnunetv2/training/loss/compound_losses.py, lines 8–56 · score 0.63 · cross entropy loss, Dice loss, weighting, masks, class
  6. [6] § Materials and methods › Implementation, experiments and evaluation metrics ↔ head_seg/metrics.py, lines 38–61 · score 0.60 · Focal loss, cross entropy, metrics, predictions
  7. [7] § Materials and methods › Implementation, experiments and evaluation metrics ↔ brain_seg/eval_diff_methods.py, lines 114–174 · score 0.60 · Hausdorff distance, MONAI, PyTorch, batch, precision, sensitivity
  8. [8] § Materials and methods › Head circumference algorithm › Elliptical fitting ↔ head_seg/entire_pipeline.py, lines 110–136 · score 0.58 · fitted ellipse, head circumference, axis, slice
  9. [9] § Experimental results and discussion › Head segmentation model results ↔ head_seg/ablation.py, lines 276–356 · score 0.53 · Shapiro Wilk, Bonferroni correction, metrics, head, model
  10. [10] § Materials and methods › Implementation, experiments and evaluation metrics ↔ nnUNet-master/nnunetv2/imageio/base_reader_writer.py, lines 21–107 · score 0.53 · voxel spacing, predicted segmentation, dimensions, resampled, axis
  11. [11] § Materials and methods › Implementation, experiments and evaluation metrics ↔ nnUNet-master/nnunetv2/training/nnUNetTrainer/nnUNetTrainer.py, lines 1020–1085 · score 0.52 · predicted segmentation, TN, FP, TP, FN, PyTorch
  12. [12] § Materials and methods › Proposed model architecture ↔ head_seg/triatt_nnet.py, lines 177–224 · score 0.51 · encoder block, deep supervision, bottleneck, ECA, SE, ASPP
  13. [13] § Materials and methods › Proposed model architecture ↔ brain_seg/triatt.py, lines 174–214 · score 0.51 · encoder block, deep supervision, bottleneck, ECA, SE, ASPP

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 · 363 lines · 12 KB · no license · 3 matches

  1. #!/usr/bin/env python3
  2. """
  3. End-to-end fetal brain segmentation and biometry pipeline.
  5. Stages:
  6. 1. Head localization (Tri-Attention nnU-Net)
  7. 2. Head circumference estimation (ellipse fitting)
  8. 3. Brain parenchyma + extraaxial CSF segmentation (nnU-Net)
  10. Associated publication:
  11. An end-to-end pipeline for automated
  12. fetal brain segmentation and biometry from 3D SSFP MRI.
  13. Frontiers in Neuroscience (2026). doi:10.3389/fnins.2026.1870124
  14. """
  16. from __future__ import annotations
  18. import argparse
  19. import json
  20. import math
  21. import os
  22. import sys
  23. import time
  24. from pathlib import Path
  26. import cv2
  27. import nibabel as nib
  28. import numpy as np
  29. import torch
  30. from nnunetv2.inference.predict_from_raw_data import nnUNetPredictor
  32. # Ensure project root is on path for config import
  33. PROJECT_ROOT = Path(__file__).resolve().parent.parent
  34. sys.path.insert(0, str(PROJECT_ROOT))
  35. import config
  37. DEFAULT_HEAD_MODEL_PATH = Path(config.HEAD_MODEL_PATH)
  38. DEFAULT_BRAIN_MODEL_PATH = Path(config.BRAIN_MODEL_PATH)
  40. NUM_CLASSES = 3
  41. CLASS_NAMES = ["background", "brain", "extraaxial_csf"]
  42. DEVICE = "cuda" if torch.cuda.is_available() and config.DEVICE != "cpu" else "cpu"
  45. def load_nifti(path: str | Path) -> tuple[np.ndarray, tuple[float, float, float]]:
  46. """Load a NIfTI volume and return (data, spacing)."""
  47. path = str(path)
  48. try:
  49. img = nib.load(path)
  50. except nib.filebasedimages.ImageFileError:
  51. import shutil
  52. import tempfile
  54. tmp = tempfile.NamedTemporaryFile(suffix=".nii", delete=False)
  55. with open(path, "rb") as f_in:
  56. shutil.copyfileobj(f_in, tmp)
  57. tmp.close()
  58. img = nib.load(tmp.name)
  59. data = img.get_fdata()
  60. spacing = img.header.get_zooms()[:3]
  61. os.remove(tmp.name)
  62. return data, spacing
  64. return img.get_fdata(), img.header.get_zooms()[:3]
  67. def save_nifti(data: np.ndarray, reference_path: str | Path, output_path: str | Path) -> None:
  68. ref = nib.load(str(reference_path))
  69. out = nib.Nifti1Image(data.astype(np.float32), ref.affine, ref.header)
  70. Path(output_path).parent.mkdir(parents=True, exist_ok=True)
  71. nib.save(out, str(output_path))
  74. def crop_to_head_roi(image: np.ndarray, head_pred: np.ndarray, margin: int = 10):
  75. coords = np.argwhere(head_pred > 0)
  76. if coords.shape[0] == 0:
  77. return image, None
  79. z_min, y_min, x_min = coords.min(axis=0)
  80. z_max, y_max, x_max = coords.max(axis=0)
  82. z_min = max(z_min - margin, 0)
  83. y_min = max(y_min - margin, 0)
  84. x_min = max(x_min - margin, 0)
  85. z_max = min(z_max + margin, image.shape[1])
  86. y_max = min(y_max + margin, image.shape[2])
  87. x_max = min(x_max + margin, image.shape[3])
  89. cropped = image[:, z_min:z_max, y_min:y_max, x_min:x_max]
  90. bbox = (z_min, z_max, y_min, y_max, x_min, x_max)
  91. return cropped, bbox
  94. def restore_to_full(seg_cropped: np.ndarray, bbox, original_shape: tuple) -> np.ndarray:
  95. if bbox is None:
  96. return seg_cropped
  98. full = np.zeros(original_shape, dtype=seg_cropped.dtype)
  99. z_min, z_max, y_min, y_max, x_min, x_max = bbox
  100. full[z_min:z_max, y_min:y_max, x_min:x_max] = seg_cropped
  101. return full
  104. def ellipse_circumference(a: float, b: float) -> float:
  105. """Ramanujan's second approximation for ellipse perimeter."""
  106. h = ((a - b) ** 2) / ((a + b) ** 2)
  107. return math.pi * (a + b) * (1 + (3 * h) / (10 + math.sqrt(4 - 3 * h)))
  110. def compute_head_circumference(head_pred_3d: np.ndarray, spacing) -> float | None:
  111. best_area = 0
  112. best_slice = None
  113. for i in range(head_pred_3d.shape[0]):
  114. slc = (head_pred_3d[i] > 0).astype(np.uint8)
  115. area = np.count_nonzero(slc)
  116. if area > best_area:
  117. best_area = area
  118. best_slice = slc
  120. if best_slice is None or best_area == 0:
  121. return None
  123. contours, _ = cv2.findContours(best_slice, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
  124. if not contours:
  125. return None
  127. largest = max(contours, key=cv2.contourArea)
  128. if len(largest) < 5:
  129. return None
  131. (center, axes, _angle) = cv2.fitEllipse(largest)
  132. _cx, _cy = center
  133. axis_major, axis_minor = axes
  134. a = (axis_major / 2) * spacing[1]
  135. b = (axis_minor / 2) * spacing[2]
  136. return ellipse_circumference(a, b)
  139. def build_predictors(
  140. head_model_path: str,
  141. brain_model_path: str,
  142. head_checkpoint: str = "checkpoint_final.pth",
  143. brain_checkpoint: str = "checkpoint_final.pth",
  144. ):
  145. head_predictor = nnUNetPredictor(
  146. tile_step_size=0.5,
  147. use_gaussian=True,
  148. use_mirroring=True,
  149. perform_everything_on_device=(DEVICE == "cuda"),
  150. device=torch.device(DEVICE),
  151. )
  152. head_predictor.initialize_from_trained_model_folder(
  153. head_model_path, use_folds=(0,), checkpoint_name=head_checkpoint
  154. )
  156. brain_predictor = nnUNetPredictor(
  157. tile_step_size=0.5,
  158. use_gaussian=True,
  159. use_mirroring=True,
  160. perform_everything_on_device=(DEVICE == "cuda"),
  161. device=torch.device(DEVICE),
  162. )
  163. brain_predictor.initialize_from_trained_model_folder(
  164. brain_model_path, use_folds=(0,), checkpoint_name=brain_checkpoint
  165. )
  166. return head_predictor, brain_predictor
  169. def run_full_pipeline(
  170. nifti_path: str | Path,
  171. head_predictor: nnUNetPredictor,
  172. brain_predictor: nnUNetPredictor,
  173. ) -> dict:
  174. img, spacing = load_nifti(nifti_path)
  175. img = img[None].astype(np.float32)
  176. properties = {"spacing": list(spacing)}
  178. if DEVICE == "cuda":
  179. torch.cuda.reset_peak_memory_stats()
  180. torch.cuda.synchronize()
  181. start = time.time()
  183. head_pred = head_predictor.predict_single_npy_array(img, properties, None, None, False)
  184. hc_mm = compute_head_circumference(head_pred, spacing)
  185. cropped_img, bbox = crop_to_head_roi(img, head_pred, margin=10)
  186. seg_pred_crop = brain_predictor.predict_single_npy_array(
  187. cropped_img, properties, None, None, False
  188. )
  189. seg_pred = restore_to_full(seg_pred_crop, bbox, head_pred.shape)
  191. if DEVICE == "cuda":
  192. torch.cuda.synchronize()
  193. elapsed = time.time() - start
  194. peak_mem = (
  195. torch.cuda.max_memory_allocated() / (1024**3) if DEVICE == "cuda" else None
  196. )
  198. return {
  199. "head_mask": head_pred,
  200. "segmentation": seg_pred,
  201. "head_circumference_mm": hc_mm,
  202. "inference_time_sec": elapsed,
  203. "peak_gpu_memory_gb": peak_mem,
  204. "spacing": spacing,
  205. }
  208. def collect_inputs(input_path: Path) -> list[Path]:
  209. if input_path.is_file():
  210. return [input_path]
  211. if input_path.is_dir():
  212. files = sorted(input_path.glob("*.nii.gz")) + sorted(input_path.glob("*.nii"))
  213. return files
  214. raise FileNotFoundError(f"Input path not found: {input_path}")
  217. def parse_args() -> argparse.Namespace:
  218. parser = argparse.ArgumentParser(
  219. description="Fetal brain segmentation and biometry pipeline (SSFP MRI)"
  220. )
  221. parser.add_argument(
  222. "--input",
  223. type=Path,
  224. default=Path(config.INFERENCE_INPUT_DIR),
  225. help="Input NIfTI file or directory of volumes",
  226. )
  227. parser.add_argument(
  228. "--output",
  229. type=Path,
  230. default=Path(config.OUTPUT_DIR),
  231. help="Directory for segmentation outputs and summary JSON",
  232. )
  233. parser.add_argument(
  234. "--head-model",
  235. type=Path,
  236. default=DEFAULT_HEAD_MODEL_PATH,
  237. help=f"Path to trained head segmentation nnU-Net model folder (default: {DEFAULT_HEAD_MODEL_PATH})",
  238. )
  239. parser.add_argument(
  240. "--brain-model",
  241. type=Path,
  242. default=DEFAULT_BRAIN_MODEL_PATH,
  243. help=f"Path to trained brain segmentation nnU-Net model folder (default: {DEFAULT_BRAIN_MODEL_PATH})",
  244. )
  245. parser.add_argument(
  246. "--head-checkpoint",
  247. type=str,
  248. default="checkpoint_final.pth",
  249. help="Checkpoint filename inside fold_0/ for the head model (e.g. checkpoint_best.pth)",
  250. )
  251. parser.add_argument(
  252. "--brain-checkpoint",
  253. type=str,
  254. default="checkpoint_final.pth",
  255. help="Checkpoint filename inside fold_0/ for the brain model (e.g. checkpoint_best.pth)",
  256. )
  257. parser.add_argument(
  258. "--gt-dir",
  259. type=Path,
  260. default=None,
  261. help="Optional ground-truth labels directory for evaluation",
  262. )
  263. return parser.parse_args()
  266. def main() -> None:
  267. args = parse_args()
  268. gt_dir = args.gt_dir or (Path(config.INFERENCE_GT_DIR) if config.INFERENCE_GT_DIR else None)
  270. if not args.head_model.exists():
  271. sys.exit(f"Head model not found: {args.head_model}")
  272. if not args.brain_model.exists():
  273. sys.exit(f"Brain model not found: {args.brain_model}")
  275. args.output.mkdir(parents=True, exist_ok=True)
  276. inputs = collect_inputs(args.input)
  277. if not inputs:
  278. sys.exit(f"No NIfTI files found in {args.input}")
  280. print(f"Device: {DEVICE}")
  281. print(f"Loading models from:\n Head: {args.head_model}\n Brain: {args.brain_model}")
  282. head_predictor, brain_predictor = build_predictors(
  283. str(args.head_model),
  284. str(args.brain_model),
  285. head_checkpoint=args.head_checkpoint,
  286. brain_checkpoint=args.brain_checkpoint,
  287. )
  289. results = []
  290. for nifti_path in inputs:
  291. case_id = nifti_path.name.replace("_0000.nii.gz", "").replace("_0000.nii", "")
  292. case_id = case_id.replace(".nii.gz", "").replace(".nii", "")
  294. out = run_full_pipeline(nifti_path, head_predictor, brain_predictor)
  296. head_out = args.output / f"{case_id}_head_mask.nii.gz"
  297. seg_out = args.output / f"{case_id}_brain_seg.nii.gz"
  298. save_nifti(out["head_mask"], nifti_path, head_out)
  299. save_nifti(out["segmentation"], nifti_path, seg_out)
  301. hc = out["head_circumference_mm"]
  302. hc_str = f"{hc:.2f} mm" if hc is not None else "N/A"
  303. print(
  304. f"{nifti_path.name} → time: {out['inference_time_sec']:.2f}s | "
  305. f"head circumference: {hc_str}"
  306. )
  308. entry = {
  309. "case_id": case_id,
  310. "input": str(nifti_path),
  311. "head_mask": str(head_out),
  312. "segmentation": str(seg_out),
  313. "head_circumference_mm": None if hc is None else float(hc),
  314. "inference_time_sec": float(out["inference_time_sec"]),
  315. "peak_gpu_memory_gb": (
  316. None
  317. if out["peak_gpu_memory_gb"] is None
  318. else float(out["peak_gpu_memory_gb"])
  319. ),
  320. }
  322. if gt_dir and gt_dir.exists():
  323. gt_path = gt_dir / f"{case_id}.nii.gz"
  324. if not gt_path.exists():
  325. gt_path = gt_dir / f"{case_id}.nii"
  326. if gt_path.exists():
  327. gt, _ = load_nifti(gt_path)
  328. pred = out["segmentation"]
  329. if pred.ndim > 3:
  330. pred = np.squeeze(pred)
  331. if gt.ndim > 3:
  332. gt = np.squeeze(gt)
  333. entry["metrics"] = {
  334. cname: {
  335. "dice": float(
  336. 2 * np.sum((pred == c) & (gt == c))
  337. / (np.sum(pred == c) + np.sum(gt == c) + 1e-8)
  338. )
  339. for cname, c in zip(CLASS_NAMES, range(NUM_CLASSES))
  340. }
  341. }
  343. results.append(entry)
  345. summary_path = args.output / "pipeline_summary.json"
  346. with open(summary_path, "w", encoding="utf-8") as f:
  347. json.dump(results, f, indent=2)
  349. times = [r["inference_time_sec"] for r in results]
  350. print("\n" + "=" * 60)
  351. print("PIPELINE SUMMARY")
  352. print("=" * 60)
  353. print(f"Cases processed: {len(results)}")
  354. print(f"Avg inference time: {np.mean(times):.2f} ± {np.std(times):.2f} sec")
  355. valid_hc = [r["head_circumference_mm"] for r in results if r["head_circumference_mm"]]
  356. if valid_hc:
  357. print(f"Avg head circumference: {np.mean(valid_hc):.2f} ± {np.std(valid_hc):.2f} mm")
  358. print(f"Results saved to: {args.output}")
  359. print(f"Summary JSON: {summary_path}")
  362. if __name__ == "__main__":
  363. main()

entire_pipeline.py at commit 781b0ac, no license · at the source

Overview

Authors: Yasmin Modarai1, Adam Lim1,2, Justin Lo1,2, Matthias W. Wagner3,4, Elka Miller3,5,6, Logi Vidarsson6, Birgit Ertl-Wagner3,5,6, Dafna Sussman1,2,7
  1. Department of Electrical, Computer and Biomedical Engineering, Faculty of Engineering and Architectural Sciences, Toronto Metropolitan University, Toronto, ON, Canada
  2. Institute for Biomedical Engineering, Science and Technology (iBEST), Toronto Metropolitan University and St. Michael’s Hospital, Toronto, ON, Canada
  3. Division of Neuroradiology, Department of Diagnostic & Interventional Radiology, The Hospital for Sick Children, Toronto, ON, Canada
  4. Institute of Diagnostic and Interventional Neuroradiology, University Hospital Augsburg, Augsburg, Germany
  5. Neurosciences & Mental Health Program, Research Institute, The Hospital for Sick Children, Toronto, ON, Canada
  6. Department of Medical Imaging, University of Toronto, Toronto, ON, Canada
  7. Department of Obstetrics and Gynecology, Faculty of Medicine, University of Toronto, Toronto, ON, Canada
Institutions: Toronto Metropolitan University (Canada); St. Michael's Hospital (Canada); Great Ormond Street Hospital (United Kingdom); Hospital for Sick Children (Canada); University Hospital Augsburg (Germany); University of Toronto (Canada)
Journal: Frontiers in neuroscience, volume 20, article 1870124
Dates: received 30 April 2026; accepted 15 June 2026; published online 9 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnins.2026.1870124 · PMID 42495270 · PMCID PMC13391945 · OpenAlex W7167818373
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality)
Methods: Connectivity, Smoothing, state filtering, decompositions, Machine learning
Keywords: deep learning, fetal, fetal brain, MRI, nnU-Net, segmentation, SSFP MRI
Topic: Fetal and Pediatric Neurological Disorders (Pediatrics, Perinatology and Child Health, Medicine), according to OpenAlex
Funding: Natural Sciences and Engineering Research Council of Canada (202303PJT-496119-MPI-ABAF-192837, ER21-16-130, RGPIN-2018-04155)
Citations: not cited yet (Europe PMC); 34 references in the paper

Abstract

Fetal magnetic resonance imaging (MRI) plays an essential role for the evaluation of fetal abnormalities, offering improved visualization of developing brain structures and superior soft tissue contrast in comparison to other imaging modalities. Accurate and reproducible assessment of fetal brain biometry is critical for diagnosing neurodevelopmental abnormalities. However, these measurements typically rely on manual segmentation, which is time-consuming, labor-intensive, prone to error and dependent on the interpreting radiologist’s expertise and experience. Recent advancements have enabled automated analysis primarily on Half-Fourier Acquisition Single-shot Turbo spin-Echo (HASTE) sequences, yet these acquisitions are susceptible to inter-slice misalignment and often require time-consuming super-resolution reconstruction. In contrast, 3D Steady-State Free Precession (SSFP) imaging offers smaller slice thickness, improving through-plane resolution, along with reduced motion sensitivity and whole-body coverage in a single scan. In this study, we present an end-to-end deep learning pipeline for automated segmentation and biometry of the fetal brain from whole-body SSFP MRI. The dataset includes manual annotations of the fetal head, brain parenchyma and extraaxial cerebrospinal fluid (CSF). The framework employs nnU-Net for robust head localization and multi-structure segmentation, along with principal component analysis (PCA)-based reorientation and head circumference estimation. A Tri-Attention U-Net architecture was evaluated as a standalone model and within the nnU-Net framework. The final pipeline consists of a Tri-Attention nnU-Net for head localization and nnU-Net for multi-structure segmentation. The pipeline achieved mean Dice similarity coefficients (DSC) of 94.48, 93.58 and 82.75% for the head, brain parenchyma and extraaxial CSF, respectively. These findings demonstrate the feasibility of accurate, fully automated fetal brain biometry from SSFP MRI with potential to reduce inter-observer variability, streamline clinical workflows and enhance clinical decision-making through fast and reproducible quantitative assessment.

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

DrSussmanLab/fetal-brain-seg

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 781b0ac7e03f1aa5c36479e288eb2116d64fd704, 9 July 2026
Languages: Python (222), Shell (6)
Size: 281 files, 228 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, environment (docker-compose.yml, Dockerfile, requirements-inference.txt, requirements-nnunet-inference.txt, requirements.txt, nnUNet-master/pyproject.toml, nnUNet-master/setup.py), tests, documentation
Not found: license file, CITATION.cff, continuous integration
Tools: nnU-Net (115 files), NumPy (81 files), PyTorch (64 files), NiBabel (14 files), SimpleITK (13 files), MONAI (12 files), SciPy (10 files), Matplotlib (9 files), scikit-learn (6 files), pandas (5 files), scikit-image (4 files), FSL (2 files), imageio (2 files), tifffile (2 files), OpenCV (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
229 files
At the source: github.com/DrSussmanLab/fetal-brain-seg

The paper's code and data availability statement is in the Data section.

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;
  • 228 scripts, each with its path and the digest of its content;
  • 13 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 statement

The data analyzed in this study is subject to the following licenses/restrictions: the datasets generated during and/or analyzed during the current study are not publicly available due to legal restrictions but are available from the corresponding author on reasonable request of a data sharing agreement. The code will be made available when published at: https://github.com/DrSussmanLab/fetal-brain-seg. Requests to access these datasets should be directed to Dafna Sussman, .

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, 8 authors, 7 keywords, 1 funder, 32 references.

Cite

This paper

Modarai, Y., Lim, A., Lo, J., Wagner, M. W., Miller, E., Vidarsson, L., Ertl-Wagner, B., & Sussman, D. (2026). An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI. Frontiers in neuroscience, 20, 1870124. https://doi.org/10.3389/fnins.2026.1870124

BibTeX

@article{modarai2026end,
author = {Modarai, Yasmin and Lim, Adam and Lo, Justin and Wagner, Matthias W. and Miller, Elka and Vidarsson, Logi and Ertl-Wagner, Birgit and Sussman, Dafna},
title = {{An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI}},
journal = {Frontiers in neuroscience},
year = {2026},
month = jul,
volume = {20},
pages = {1870124},
publisher = {Frontiers Media SA},
issn = {1662-4548},
doi = {10.3389/fnins.2026.1870124},
url = {https://doi.org/10.3389/fnins.2026.1870124},
pmid = {42495270},
pmcid = {PMC13391945}
}

RIS

TY - JOUR
AU - Modarai, Yasmin
AU - Lim, Adam
AU - Lo, Justin
AU - Wagner, Matthias W.
AU - Miller, Elka
AU - Vidarsson, Logi
AU - Ertl-Wagner, Birgit
AU - Sussman, Dafna
TI - An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI
T2 - Frontiers in neuroscience
J2 - Front Neurosci
PY - 2026
DA - 2026/07/09
VL - 20
SP - 1870124
SN - 1662-4548
PB - Frontiers Media SA
DO - 10.3389/fnins.2026.1870124
UR - https://doi.org/10.3389/fnins.2026.1870124
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnins.2026.1870124",
"type": "article-journal",
"title": "An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI",
"container-title": "Frontiers in neuroscience",
"author": [
{
"family": "Modarai",
"given": "Yasmin"
},
{
"family": "Lim",
"given": "Adam"
},
{
"family": "Lo",
"given": "Justin"
},
{
"family": "Wagner",
"given": "Matthias W."
},
{
"family": "Miller",
"given": "Elka"
},
{
"family": "Vidarsson",
"given": "Logi"
},
{
"family": "Ertl-Wagner",
"given": "Birgit"
},
{
"family": "Sussman",
"given": "Dafna"
}
],
"container-title-short": "Front Neurosci",
"volume": "20",
"page": "1870124",
"DOI": "10.3389/fnins.2026.1870124",
"PMID": "42495270",
"PMCID": "PMC13391945",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnins.2026.1870124",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
9
]
]
}
}

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.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: nnU-Net, MONAI, imageio, 11 other tools, structural MRI / diffusion
[2] doi:10.1186/s12880-026-02481-2 [code]
Deep learning-based neuroanatomical profiling reveals population-specific brain changes in multiple sclerosis: a large-scale Middle Eastern study.
Journal: BMC medical imaging
In common: imageio, FSL, OpenCV, 8 other tools, structural MRI / diffusion, 4 references
[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, 10 other tools, structural MRI / diffusion, 1 reference
[4] 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, FSL, 10 other tools, structural MRI / diffusion
[5] 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, structural MRI / diffusion, 1 reference
[6] 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, structural MRI / diffusion, 1 reference
[7] 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, structural MRI / diffusion, 1 reference
[8] 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
[9] 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
[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, MONAI, SimpleITK, 9 other tools, structural MRI / diffusion

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.