OSCR

Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI.

Code ↔ Paper

6 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 6 matches
  1. [1] § Experimental setup and metrics › Experimental setup ↔ src/MedNeXtTrainer.py, lines 12–89 · score 0.85 · AdamW, weight decay, MedNeXt, PyTorch, batch, patch
  2. [2] § Datasets and preprocessing › Preprocessing ↔ preprocess/preprocess_CNP.ipynb, lines 29–38 · score 0.65 · SlicerDMRI, diffusion tensor, fit, preprocessing, DWI
  3. [3] § Experimental setup and metrics › Experimental setup ↔ preprocess/preprocess_CNP.ipynb, lines 215–295 · score 0.58 · Min eigenvalue, Mid eigenvalue, Max eigenvalue, Linearity, Planarity, Trace
  4. [4] § Experimental setup and metrics › Experimental setup ↔ src/monaiTrainer.py, lines 10–67 · score 0.56 · SwinUnetr, PyTorch, batch, patch, modules, architecture
  5. [5] § Methodology › Post-processing ↔ utils/conform.py, lines 272–288 · score 0.53 · largest connected component, background, segmentation
  6. [6] § Methodology › Post-processing ↔ utils/load_neuroimaging_data.py, lines 1328–1342 · score 0.53 · largest connected component, background, segmentation

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

Jupyter notebook · 490 lines · 16 KB · Apache-2.0 · 2 matches

  1. # %%
  2. import os
  3. import shutil
  4. from glob import glob
  5. from joblib import Parallel, delayed
  6. from tqdm.auto import tqdm
  7. import subprocess
  8. from copy import copy, deepcopy
  10. import numpy as np
  11. import nibabel as nib
  12. from dipy.io import read_bvals_bvecs
  13. from dipy.io.image import load_nifti, save_nifti
  14. from dipy.core.gradients import gradient_table
  15. from dipy.reconst.dti import TensorModel, _roll_evals
  16. import sys
  18. sys.path.append("../utils")
  19. from load_neuroimaging_data import load_and_conform_image, map_wmparc2gtseg
  20. import json
  22. join = os.path.join
  24. # %%
  25. with open("../splits/CNP_patients.txt", "r") as f:
  26. patient_ids = [line.strip() for line in f]
  27. patient_ids = sorted(patient_ids)
  29. # %% [markdown]
  30. # # 3D Slicer Paths and other paths
  32. # %%
  33. DWIToDTIEstimation = "/home/say26747/Downloads/Slicer-5.2.2-linux-amd64/Slicer --launch /home/say26747/Downloads/Slicer-5.2.2-linux-amd64/NA-MIC/Extensions-31382/SlicerDMRI/lib/Slicer-5.2/cli-modules/DWIToDTIEstimation"
  34. DiffusionTensorScalarMeasurements = "/home/say26747/Downloads/Slicer-5.2.2-linux-amd64/Slicer --launch /home/say26747/Downloads/Slicer-5.2.2-linux-amd64/NA-MIC/Extensions-31382/SlicerDMRI/lib/Slicer-5.2/cli-modules/DiffusionTensorScalarMeasurements"
  35. BRAINSFit = "/home/say26747/Downloads/Slicer-5.2.2-linux-amd64/Slicer --launch /home/say26747/Downloads/Slicer-5.2.2-linux-amd64/lib/Slicer-5.2/cli-modules/BRAINSFit"
  36. ResampleScalarVectorDWIVolume = "/home/say26747/Downloads/Slicer-5.2.2-linux-amd64/Slicer --launch /home/say26747/Downloads/Slicer-5.2.2-linux-amd64/lib/Slicer-5.2/cli-modules/ResampleScalarVectorDWIVolume"
  37. MNI_template_brain_only = "/hdd/HPC100_preprocess/tpl-MNI152NLin6Sym/tpl-MNI152NLin6Sym_res-01_T1w_Brain_only.nii.gz"
  38. CNN_masking_path = "/home/say26747/Desktop/git/CNN-Diffusion-MRIBrain-Segmentation" # look for its repository on the web
  40. # %% [markdown]
  41. # # Unring data
  43. # %%
  44. root_data_dir = "/hdd/CNP_dataset/data/"
  47. def worker_unring(patient_id):
  48. dwi_path = join(
  49. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi.nii.gz"
  50. ) # change accordingly
  51. dwi_unring_path = join(
  52. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring"
  53. ) # change accordingly
  54. if os.path.exists(dwi_unring_path + ".nii.gz"):
  55. print(f"{dwi_unring_path} already exists")
  56. return
  57. # Define the Conda environment name
  58. conda_env_name = "fsl_base" # Replace this with your environment name
  59. command = f"conda run -n {conda_env_name} unring {dwi_path} {dwi_unring_path}"
  60. subprocess.run(command, shell=True, executable="/bin/bash", check=True)
  62. # %%
  63. results = Parallel(n_jobs=4)(
  64. delayed(worker_unring)(patient_id) for patient_id in tqdm(patient_ids)
  65. )
  67. # %% [markdown]
  68. # # Eddy correction
  70. # %%
  71. def worker_eddy_correction(patient_id):
  72. dwi_unring_path = join(
  73. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring.nii.gz"
  74. )
  75. dwi_eddy_path = join(
  76. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring_eddy"
  77. )
  78. dwi_bvals_path = join(
  79. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring.bval"
  80. )
  81. dwi_bvecs_path = join(
  82. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring.bvec"
  83. )
  84. if os.path.exists(dwi_eddy_path + ".nii.gz"):
  85. print(f"{dwi_eddy_path} already exists")
  86. return
  87. # Define the Conda environment name
  88. conda_env_name = "fsl_base" # Replace this with your environment name
  89. command = f"conda run -n {conda_env_name} pnl_eddy --bvals {dwi_bvals_path} --bvecs {dwi_bvecs_path} -i {dwi_unring_path} -o {dwi_eddy_path}"
  90. # print(command)
  91. subprocess.run(command, shell=True, executable="/bin/bash")
  93. # %%
  94. results = Parallel(n_jobs=4)(
  95. delayed(worker_eddy_correction)(patient_id) for patient_id in tqdm(patient_ids)
  96. )
  98. # %% [markdown]
  99. # # Masking using masking_CNN
  101. # %%
  102. dwi_eddy_paths = []
  103. for patient_id in patient_ids:
  104. dwi_eddy_path = dwi_eddy_path = join(
  105. root_data_dir, patient_id, "dwi", f"{patient_id}_dwi_unring_eddy.nii.gz"
  106. )
  107. if os.path.exists(dwi_eddy_path):
  108. dwi_eddy_paths.append(dwi_eddy_path)
  109. else:
  110. print(f"{dwi_eddy_path} does not exist")
  111. print(len(dwi_eddy_paths))
  113. # save the patient ids to a file (each path in one line)
  114. with open("/hdd/CNP_dataset/dwi_eddy_paths.txt", "w") as f:
  115. for path in dwi_eddy_paths:
  116. f.write(path + "\n")
  118. # %%
  119. for path in tqdm(dwi_eddy_paths):
  120. parent_dir = os.path.dirname(path)
  121. txt_file = join(parent_dir, "dwi_eddy_path.txt")
  122. masking_path = join(CNN_masking_path, "pipeline", "dwi_masking.py")
  123. model_path = join(CNN_masking_path, "model_folder")
  124. command = f"/home/say26747/anaconda3/bin/conda run -n dmri_seg {masking_path} -i {txt_file} -f {model_path} -filter scipy -p 97 -nproc 4"
  125. subprocess.run(command, shell=True, check=True, executable="/bin/bash")
  126. break
  128. # %% [markdown]
  129. # # diffusion-derived features
  131. # %%
  132. def worker_dwi_calculation(patient_id):
  133. dest_path = f"/hdd/CNP_dataset/data/{patient_id}/DATA"
  134. temp_dir = "/hdd/tmp/diffusion"
  135. os.makedirs(dest_path, exist_ok=True)
  136. os.makedirs(join(temp_dir, patient_id), exist_ok=True)
  137. dwi_root_path = f"/hdd/CNP_dataset/data/{patient_id}/dwi"
  138. if os.path.exists(join(dest_path, "trace_from_eigs.nii.gz")):
  139. print(f"Already processed {patient_id}")
  140. return
  141. # load the bvals and bvecs
  142. bvals, bvecs = read_bvals_bvecs(
  143. join(dwi_root_path, f"{patient_id}_dwi_unring_eddy.bval"),
  144. join(dwi_root_path, f"{patient_id}_dwi_unring_eddy.bvec"),
  145. )
  146. # load the DWI data
  147. dwi_data, dwi_affine = load_nifti(
  148. join(dwi_root_path, f"{patient_id}_dwi_unring_eddy.nii.gz")
  149. )
  151. b_value_threshold = 50
  152. b0_indecies = np.where(bvals < b_value_threshold)[0]
  153. b1000_indecies = np.where(np.abs(bvals - 1000) < b_value_threshold)[0]
  154. combined_indecies = np.concatenate([b0_indecies, b1000_indecies])
  155. dwi_filtered_data = dwi_data[..., combined_indecies]
  156. bvals_filtered = bvals[combined_indecies]
  157. bvecs_filtered = bvecs[combined_indecies]
  158. # save the filtered data
  159. save_nifti(join(temp_dir, patient_id, "DWI.nii.gz"), dwi_filtered_data, dwi_affine)
  160. # save the filtered bvals and bvecs
  161. np.savetxt(join(temp_dir, patient_id, "bvals"), bvals_filtered)
  162. np.savetxt(join(temp_dir, patient_id, "bvecs"), bvecs_filtered)
  163. # now write tell where to save the nhdr file
  164. dwi_nhdr = join(temp_dir, patient_id, "DWI_nhdr.nhdr")
  165. mask_nhdr = join(temp_dir, patient_id, "mask_nhdr.nhdr")
  166. subprocess.run(
  167. [
  168. "nhdr_write.py",
  169. "--nifti",
  170. join(temp_dir, patient_id, "DWI.nii.gz"),
  171. "--bval",
  172. join(temp_dir, patient_id, "bvals"),
  173. "--bvec",
  174. join(temp_dir, patient_id, "bvecs"),
  175. "--nhdr",
  176. dwi_nhdr,
  177. ]
  178. )
  179. shutil.copy(
  180. join(dwi_root_path, f"{patient_id}_dwi_unring_eddy_bse-multi_BrainMask.nii.gz"),
  181. join(temp_dir, patient_id, "mask.nii.gz"),
  182. )
  183. subprocess.run(
  184. [
  185. "nhdr_write.py",
  186. "--nifti",
  187. join(temp_dir, patient_id, "mask.nii.gz"),
  188. "--nhdr",
  189. mask_nhdr,
  190. ]
  191. )
  192. dti_nhdr = join(temp_dir, patient_id, "DTI.nhdr")
  193. b0_nhdr = join(temp_dir, patient_id, "b0.nhdr")
  194. subprocess.run(
  195. DWIToDTIEstimation.split()
  196. + [
  197. "--enumeration",
  198. "LS",
  199. dwi_nhdr,
  200. dti_nhdr,
  201. b0_nhdr,
  202. "-m",
  203. mask_nhdr,
  204. ]
  205. )
  206. fa_nhdr = join(temp_dir, patient_id, "FA.nhdr")
  207. trace_nhdr = join(temp_dir, patient_id, "trace.nhdr")
  208. minEig_nhdr = join(temp_dir, patient_id, "minEig.nhdr")
  209. midEig_nhdr = join(temp_dir, patient_id, "midEig.nhdr")
  210. maxEig_nhdr = join(temp_dir, patient_id, "maxEig.nhdr")
  211. planarity_nhdr = join(temp_dir, patient_id, "planarity.nhdr")
  212. linearity_nhdr = join(temp_dir, patient_id, "linearity.nhdr")
  213. sphericity_nhdr = join(temp_dir, patient_id, "sphericity.nhdr")
  215. fa_nifti = join(dest_path, "FA.nii.gz")
  216. trace_nifti = join(dest_path, "trace.nii.gz")
  217. minEig_nifti = join(dest_path, "minEig.nii.gz")
  218. midEig_nifti = join(dest_path, "midEig.nii.gz")
  219. maxEig_nifti = join(dest_path, "maxEig.nii.gz")
  220. planarity_nifti = join(dest_path, "planarity.nii.gz")
  221. linearity_nifti = join(dest_path, "linearity.nii.gz")
  222. sphericity_nifti = join(dest_path, "sphericity.nii.gz")
  224. subprocess.run(
  225. DiffusionTensorScalarMeasurements.split()
  226. + [
  227. "--enumeration",
  228. "FractionalAnisotropy",
  229. dti_nhdr,
  230. fa_nhdr,
  231. ]
  232. )
  233. subprocess.run(
  234. DiffusionTensorScalarMeasurements.split()
  235. + [
  236. "--enumeration",
  237. "Trace",
  238. dti_nhdr,
  239. trace_nhdr,
  240. ]
  241. )
  242. subprocess.run(
  243. DiffusionTensorScalarMeasurements.split()
  244. + [
  245. "--enumeration",
  246. "MinEigenvalue",
  247. dti_nhdr,
  248. minEig_nhdr,
  249. ]
  250. )
  251. subprocess.run(
  252. DiffusionTensorScalarMeasurements.split()
  253. + [
  254. "--enumeration",
  255. "MidEigenvalue",
  256. dti_nhdr,
  257. midEig_nhdr,
  258. ]
  259. )
  260. subprocess.run(
  261. DiffusionTensorScalarMeasurements.split()
  262. + [
  263. "--enumeration",
  264. "MaxEigenvalue",
  265. dti_nhdr,
  266. maxEig_nhdr,
  267. ]
  268. )
  269. subprocess.run(
  270. DiffusionTensorScalarMeasurements.split()
  271. + [
  272. "--enumeration",
  273. "PlanarMeasure",
  274. dti_nhdr,
  275. planarity_nhdr,
  276. ]
  277. )
  278. subprocess.run(
  279. DiffusionTensorScalarMeasurements.split()
  280. + [
  281. "--enumeration",
  282. "LinearMeasure",
  283. dti_nhdr,
  284. linearity_nhdr,
  285. ]
  286. )
  287. subprocess.run(
  288. DiffusionTensorScalarMeasurements.split()
  289. + [
  290. "--enumeration",
  291. "SphericalMeasure",
  292. dti_nhdr,
  293. sphericity_nhdr,
  294. ]
  295. )
  297. subprocess.run(
  298. [
  299. "nifti_write.py",
  300. "-i",
  301. fa_nhdr,
  302. ]
  303. )
  304. subprocess.run(
  305. [
  306. "nifti_write.py",
  307. "-i",
  308. trace_nhdr,
  309. ]
  310. )
  311. subprocess.run(
  312. [
  313. "nifti_write.py",
  314. "-i",
  315. minEig_nhdr,
  316. ]
  317. )
  318. subprocess.run(
  319. [
  320. "nifti_write.py",
  321. "-i",
  322. midEig_nhdr,
  323. ]
  324. )
  325. subprocess.run(
  326. [
  327. "nifti_write.py",
  328. "-i",
  329. maxEig_nhdr,
  330. ]
  331. )
  332. subprocess.run(
  333. [
  334. "nifti_write.py",
  335. "-i",
  336. planarity_nhdr,
  337. ]
  338. )
  339. subprocess.run(
  340. [
  341. "nifti_write.py",
  342. "-i",
  343. linearity_nhdr,
  344. ]
  345. )
  346. subprocess.run(
  347. [
  348. "nifti_write.py",
  349. "-i",
  350. sphericity_nhdr,
  351. ]
  352. )
  353. subprocess.run(
  354. [
  355. "nifti_write.py",
  356. "-i",
  357. b0_nhdr,
  358. ]
  359. )
  360. # now move the needed files
  361. shutil.move(fa_nhdr.replace(".nhdr", ".nii.gz"), fa_nifti)
  362. shutil.move(trace_nhdr.replace(".nhdr", ".nii.gz"), trace_nifti)
  363. shutil.move(minEig_nhdr.replace(".nhdr", ".nii.gz"), minEig_nifti)
  364. shutil.move(midEig_nhdr.replace(".nhdr", ".nii.gz"), midEig_nifti)
  365. shutil.move(maxEig_nhdr.replace(".nhdr", ".nii.gz"), maxEig_nifti)
  366. shutil.move(planarity_nhdr.replace(".nhdr", ".nii.gz"), planarity_nifti)
  367. shutil.move(linearity_nhdr.replace(".nhdr", ".nii.gz"), linearity_nifti)
  368. shutil.move(sphericity_nhdr.replace(".nhdr", ".nii.gz"), sphericity_nifti)
  370. shutil.move(b0_nhdr.replace(".nhdr", ".nii.gz"), join(dest_path, "b0.nii.gz"))
  371. shutil.copy(
  372. join(dwi_root_path, f"{patient_id}_dwi_unring_eddy_bse-multi_BrainMask.nii.gz"),
  373. join(dest_path, "brain_mask.nii.gz"),
  374. )
  376. shutil.rmtree(join(temp_dir, patient_id))
  378. img_data, img_affine = load_nifti(
  379. join(os.path.dirname(dwi_root_path), "freesurfer", "mri", "wmparc.mgz")
  380. )
  381. save_nifti(join(dest_path, "wmparc.nii.gz"), img_data, img_affine)
  382. img_data, img_affine = load_nifti(
  383. join(os.path.dirname(dwi_root_path), "freesurfer", "mri", "T1.mgz")
  384. )
  385. save_nifti(join(dest_path, "T1.nii.gz"), img_data, img_affine)
  387. eigs_data = []
  388. eigs_affine = []
  389. for eig in ["minEig", "midEig", "maxEig"]:
  390. eig_path = join(dest_path, f"{eig}.nii.gz")
  391. eig_data, eig_affine = load_nifti(eig_path)
  392. eigs_data.append(eig_data)
  393. eigs_affine.append(eig_affine)
  394. save_nifti(
  395. join(dest_path, "trace_from_eigs.nii.gz"),
  396. np.sum(eigs_data, axis=0),
  397. eigs_affine[0],
  398. )
  399. save_nifti(
  400. join(dest_path, "MD_from_eigs.nii.gz"),
  401. np.mean(eigs_data, axis=0),
  402. eigs_affine[0],
  403. )
  405. # %%
  406. results = Parallel(n_jobs=5)(
  407. delayed(worker_dwi_calculation)(patient_id) for patient_id in tqdm(patient_ids)
  408. )
  410. # %% [markdown]
  411. # # wmparc to dwi
  413. # %%
  414. def worker_fs2dwi(patient_id):
  415. dwi_path = (
  416. f"/hdd/CNP_dataset/data/{patient_id}/dwi/{patient_id}_dwi_unring_eddy.nii.gz"
  417. )
  418. dwi_mask_path = f"/hdd/CNP_dataset/data/{patient_id}/dwi/{patient_id}_dwi_unring_eddy_bse-multi_BrainMask.nii.gz"
  419. bse_path = f"/hdd/CNP_dataset/data/{patient_id}/dwi/{patient_id}_dwi_unring_eddy_bse.nii.gz"
  420. bval_path = (
  421. f"/hdd/CNP_dataset/data/{patient_id}/dwi/{patient_id}_dwi_unring_eddy.bval"
  422. )
  423. freesurfer_path = f"/hdd/CNP_dataset/data/{patient_id}/freesurfer"
  424. dwi_root_path = f"/hdd/CNP_dataset/data/{patient_id}/dwi"
  425. fs2dwi_exc = "nifti_fs2dwi"
  427. command = f"{fs2dwi_exc} --dwi {dwi_path} --dwimask {dwi_mask_path} --bse {bse_path} --bvals {bval_path} -f {freesurfer_path} -o {dwi_root_path} direct"
  428. subprocess.run(command, shell=True, check=True)
  430. # %%
  431. results = Parallel(n_jobs=5)(
  432. delayed(worker_fs2dwi)(patient_id) for patient_id in tqdm(patient_ids)
  433. )
  435. # %% [markdown]
  436. # # Making the data registered to MNI and conformed
  438. # %%
  439. with open("../utils/wmparc_values_to_sequence.json", "r") as file:
  440. lookup_table = json.load(file)
  441. # swap the keys and values
  442. lookup_table = {v: k for k, v in lookup_table.items()}
  445. def worker_ras_MNI_conform(patient_id):
  446. root_path = f"/hdd/CNP_dataset/data/{patient_id}"
  447. wmparc_dwi_path = join(root_path, "dwi", "wmparcInDwi.nii.gz")
  448. dwi_mask_path = join(root_path, "DATA", "brain_mask.nii.gz")
  449. b0 = join(root_path, "DATA", "b0.nii.gz")
  450. # modalities=["FA", "trace_from_eigs", "maxEig", "minEig", "midEig"]
  451. modalities = ["sphericity"]
  452. img_path = join(root_path, "DATA", "images")
  453. os.makedirs(img_path, exist_ok=True)
  454. labels_path = join(root_path, "DATA", "labels")
  455. os.makedirs(labels_path, exist_ok=True)
  457. for modality in modalities:
  458. modality_path = join(root_path, "DATA", f"{modality}.nii.gz")
  459. img = nib.load(modality_path)
  460. img = img.as_reoriented(nib.orientations.io_orientation(img.affine))
  461. nib.save(img, join(img_path, f"{modality}_ras.nii.gz"))
  463. ResampleScalarVectorDWIVolume_command = (
  464. ResampleScalarVectorDWIVolume.split()
  465. + [
  466. "--interpolation",
  467. "linear",
  468. "--Reference",
  469. MNI_template_brain_only,
  470. "--transformationFile",
  471. join(root_path, "DATA", "transformations", "b0_to_MNI_Brain.tfm"),
  472. join(img_path, f"{modality}_ras.nii.gz"),
  473. join(img_path, f"{modality}_ras_MNI.nii.gz"),
  474. ]
  475. )
  476. subprocess.run(ResampleScalarVectorDWIVolume_command)
  478. modality_path = join(img_path, f"{modality}_ras_MNI.nii.gz")
  479. header_info, affine_info, data = load_and_conform_image(
  480. modality_path, interpol=3, imagetype="image"
  481. )
  482. nib.save(
  483. nib.Nifti1Image(data, affine=affine_info, header=header_info),
  484. modality_path.replace(".nii.gz", "_conform.nii.gz"),
  485. )
  487. # %%
  488. results = Parallel(n_jobs=5)(
  489. delayed(worker_ras_MNI_conform)(patient_id) for patient_id in tqdm(patient_ids)
  490. )

preprocess_CNP.ipynb at commit 31ce4ab, under Apache-2.0 · at the source

Overview

Authors: Yousef Sadegheih1, Dorit Merhof1,2
  1. Faculty of Informatics and Data Science, University of Regensburg,Regensburg, 93053 Germany
  2. Fraunhofer Institute for Digital Medicine MEVIS,Bremen, 28359 Germany
Institutions: University of Regensburg (Germany); Fraunhofer Institute for Digital Medicine (Germany)
Journal: Scientific reports, volume 16, issue 1, article 17182
Dates: received 15 October 2025; accepted 19 May 2026; published online 3 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41598-026-54446-8 · PMID 42236782 · PMCID PMC13234126 · OpenAlex W4417174513
Open access: gold, a free copy (OpenAlex)
Preprint: arxiv:2508.07815
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), methods / tools (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, fMRI & imaging
Keywords: Deep learning, Segmentation, Parcellation, Diffusion MRI, Computational biology and bioinformatics, Engineering, Mathematics and computing, Medical research, Neurology, Neuroscience
MeSH: Brain*, Deep Learning*, Diffusion Magnetic Resonance Imaging*, Image Processing, Computer-Assisted*, Neuroimaging*, Connectome, Humans (* major topic)
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Universität Regensburg (3161)
Citations: cited by 1 paper (Europe PMC); 59 references in the paper

Abstract

Accurate brain parcellation in diffusion MRI (dMRI) space is essential for advanced neuroimaging analyses. However, most existing approaches rely on anatomical MRI for segmentation and inter-modality registration, a process that can introduce errors and limit the versatility of the technique. In this study, we present a novel deep learning-based framework for direct parcellation based on the Desikan-Killiany (DK) atlas using only diffusion MRI-derived data. Our method utilizes a hierarchical, two-stage segmentation network: the first stage performs coarse parcellation into broad brain regions, and the second stage refines the segmentation to delineate more detailed subregions within each coarse category. We conduct an extensive ablation study to evaluate various diffusion-derived parameter maps, identifying a top-performing combination of fractional anisotropy, trace, sphericity, and maximum eigenvalue that enhances parcellation accuracy compared with previously used parameter choices. When evaluated on the Human Connectome Project, our approach achieves higher Dice Similarity Coefficients compared to existing state-of-the-art methods. On the Consortium for Neuropsychiatric Phenomics dataset, where reliable voxel-wise DK reference labels in diffusion space are not available, our method demonstrates label-free evidence of robustness across different image resolutions and acquisition protocols by producing more homogeneous parcellations as measured by the relative standard deviation within regions. This work represents a step toward more practical dMRI-based brain parcellation by avoiding the need for anatomical MRI and subject-specific anatomical-to-diffusion registration at inference time. The implementation of our method is publicly available on https://github.com/xmindflow/DKParcellationdMRI.

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

xmindflow/DKParcellationdMRI

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 31ce4abcdff551850687dea9e05b925cc02ee83a, 16 October 2025
Languages: Python (12), Jupyter (3), Shell (1)
Size: 34 files, 16 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, 3 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (7 files), nnU-Net (6 files), NumPy (6 files), NiBabel (5 files), DIPY (2 files), MONAI (2 files), scikit-image (2 files), SciPy (2 files), FreeSurfer (1 file), h5py (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
18 files
At the source: github.com/xmindflow/DKParcellationdMRI

Code availability

The implementation of our method is publicly available on github.com/xmindflow/DKParcellationdMRI.

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

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

Datasets cited

Data availability

The diffusion MRI and structural MRI data used in this study are publicly available. Human Connectome Project (HCP) data can be accessed at https://www.humanconnectome.org, and Consortium for Neuropsychiatric Phenomics (CNP) data are available through the OpenNeuro repository under accession number ds000030 and can be accessed at https://openneuro.org/datasets/ds000030/versions/00016. The source code and trained model implementation for the proposed framework are publicly available at https://github.com/xmindflow/DKParcellationdMRI. All data supporting the findings of this study are described within the manuscript

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, issue, pages, dates, 2 authors, 10 keywords, 7 MeSH terms, 1 funder, 43 references.

Cite

This paper

Sadegheih, Y., & Merhof, D. (2026). Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI. Scientific reports, 16(1), 17182. https://doi.org/10.1038/s41598-026-54446-8

BibTeX

@article{sadegheih2026deep,
author = {Sadegheih, Yousef and Merhof, Dorit},
title = {{Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI}},
journal = {Scientific reports},
year = {2026},
month = jun,
volume = {16},
number = {1},
pages = {17182},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-54446-8},
url = {https://doi.org/10.1038/s41598-026-54446-8},
pmid = {42236782},
pmcid = {PMC13234126}
}

RIS

TY - JOUR
AU - Sadegheih, Yousef
AU - Merhof, Dorit
TI - Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/06/03
VL - 16
IS - 1
SP - 17182
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-54446-8
UR - https://doi.org/10.1038/s41598-026-54446-8
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-54446-8",
"type": "article-journal",
"title": "Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI",
"container-title": "Scientific reports",
"author": [
{
"family": "Sadegheih",
"given": "Yousef"
},
{
"family": "Merhof",
"given": "Dorit"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "17182",
"DOI": "10.1038/s41598-026-54446-8",
"PMID": "42236782",
"PMCID": "PMC13234126",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-54446-8",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
3
]
]
}
}

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/advs.76596 [code]
DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: FreeSurfer, NiBabel, PyTorch, 2 other tools, methods / tools, structural MRI / diffusion, 16 references
[2] doi:10.1162/imag.a.1183 [code]
Learning-based segmentation of diffusion-weighted MR images with arbitrary &lt;i&gt;q&lt;/i&gt;-space samplings.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: scikit-image, h5py, NiBabel, 3 other tools, methods / tools, structural MRI / diffusion, 12 references
[3] doi:10.1007/s00234-026-03993-y [code]
A comprehensive framework for automated segmentation of perivascular spaces in brain MRI with the nnU-Net.
Journal: Neuroradiology
In common: nnU-Net, DIPY, scikit-image, 2 other tools, methods / tools, structural MRI / diffusion, 6 references
[4] doi:10.1002/nbm.70353 [code]
Automated Surface-Based Segmentation of Deep Gray Matter Regions Based on Diffusion Tensor Images Reveals Unique Age Trajectories Over the Healthy Lifespan.
Journal: NMR in biomedicine
In common: DIPY, FreeSurfer, scikit-image, 3 other tools, structural MRI / diffusion, 4 references
[5] 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, scikit-image, 5 other tools, methods / tools, structural MRI / diffusion, 1 reference
[6] doi:10.1162/imag.a.1366 [code]
MICAFlow: Fast and robust MRI preprocessing bridging research neuroimaging and clinical practice.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DIPY, FreeSurfer, NiBabel, 3 other tools, methods / tools, structural MRI / diffusion, 3 references
[7] doi:10.1038/s41398-026-04143-x [code]
Neighborhood opportunity, white matter, and cognition in a large pediatric neuroimaging study.
Journal: Translational psychiatry
In common: DIPY, scikit-image, NiBabel, 2 other tools, structural MRI / diffusion, 3 references
[8] doi:10.1038/s41467-026-71719-y [code]
Brain functional-structural gradient coupling reflects development, behavior and genetic influences.
Journal: Nature communications
In common: DIPY, FreeSurfer, h5py, 4 other tools, 3 references
[9] doi:10.1038/s41598-026-55397-w [code]
Fast surface reconstruction of human brain MRI: benchmarking deep-learning based morphometry tools.
Journal: Scientific reports
In common: FreeSurfer, scikit-image, NiBabel, 3 other tools, methods / tools, structural MRI / diffusion, 4 references
[10] doi:10.2463/mrms.mp.2024-0149 [code]
Image Distortion Correction for Diffusion MR Imaging Using a Transformer-based U-Net.
Journal: Magnetic resonance in medical sciences : MRMS : an official journal of Japan Society of Magnetic Resonance in Medicine
In common: nnU-Net, FreeSurfer, scikit-image, 4 other tools, structural MRI / diffusion, 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.

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.