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.

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

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

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.1016/j.neuroimage.2024.120603 [code]
Fetal brain MRI atlases and datasets: A review.
Journal: NeuroImage
In common: nnU-Net, MONAI, SimpleITK, 11 other tools, structural MRI / diffusion, 3 references
[2] doi:10.3390/biomedicines12112561 [code]
Transfer Learning Approaches for Brain Metastases Screenings.
Journal: Biomedicines
In common: nnU-Net, MONAI, SimpleITK, 11 other tools, 2 references
[3] 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, MONAI, imageio, 12 other tools, 1 reference
[4] 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, MONAI, SimpleITK, 10 other tools, 3 references
[5] doi:10.1038/s41598-023-44794-0 [code]
Multi-class glioma segmentation on real-world data with missing MRI sequences: comparison of three deep learning algorithms.
Journal: Scientific reports
In common: nnU-Net, MONAI, SimpleITK, 10 other tools, structural MRI / diffusion, 1 reference
[6] doi:10.1038/s41586-025-09708-2 [code]
A probabilistic histological atlas of the human brain for MRI segmentation.
Journal: Nature
In common: nnU-Net, imageio, SimpleITK, 11 other tools, structural MRI / diffusion
[7] 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
[8] doi:10.1007/s12021-024-09688-0 [code]
A Deep Learning-based Pipeline for Segmenting the Cerebral Cortex Laminar Structure in Histology Images.
Journal: Neuroinformatics
In common: nnU-Net, SimpleITK, tifffile, 10 other tools, 2 references
[9] 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, MONAI, SimpleITK, 10 other tools, structural MRI / diffusion, 1 reference
[10] doi:10.1162/imag.a.960 [code]
GOUHFI: A novel contrast- and resolution-agnostic segmentation tool for ultra-high-field MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: nnU-Net, SimpleITK, tifffile, 9 other tools, structural MRI / diffusion, 3 references

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.3389/fnins.2026.1870124.svg)](https://openscicode.org/badge/doi/10.3389/fnins.2026.1870124)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.3389/fnins.2026.1870124.svg
   :target: https://openscicode.org/badge/doi/10.3389/fnins.2026.1870124
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.3389/fnins.2026.1870124"><img src="https://openscicode.org/badge/doi/10.3389/fnins.2026.1870124.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.