OSCR

Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units.

Code ↔ Paper

18 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 18 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Recent Applications › ODF reconstruction ↔ mdt/lib/processing/model_fitting.py, lines 31–177 · score 0.75 · Nelder Mead, Levenberg Marquardt, model fitting, Powell, NODDI, precision
  2. [2] § Recent Applications › ODF reconstruction ↔ mdt/cli_scripts/mdt_model_fit.py, lines 26–161 · score 0.75 · Nelder Mead, Levenberg Marquardt, model fitting, Powell, precision, gradient
  3. [3] § Recent Applications › ODF reconstruction ↔ catractography.py, lines 208–317 · score 0.75 · Constrained spherical deconvolution, spherical harmonic, fiber orientations, CSD, efficient, tensors
  4. [4] § Recent Applications › Local tractography ↔ tractography/algorithms/probabilistic.py, lines 106–232 · score 0.71 · probabilistic algorithms, seed points, implement tractography, OpenCL, vertices, propagation
  5. [5] § Recent Applications › ODF reconstruction ↔ IronTractChallenge-2ndRound/catractography.py, lines 196–305 · score 0.66 · Constrained spherical deconvolution, fiber orientations, CSD, efficient, tensors, diffusion
  6. [6] § The Case for Massively Parallel Tractography ↔ mdt/utils.py, lines 1667–1787 · score 0.65 · neurite orientation, density imaging, HEALthy, dispersion, NODDI, fit
  7. [7] § Recent Applications › ODF reconstruction ↔ mdt/__init__.py, lines 211–320 · score 0.65 · Markov chain Monte, Carlo, MCMC, component, optimization, fit
  8. [8] § Recent Applications › Local tractography ↔ IronTractChallenge-2ndRound/catractography.py, lines 196–305 · score 0.64 · diffusion MRI, DIPY, fiber orientation, CSD, library, tracts
  9. [9] § Recent Applications › Local tractography ↔ tractography/algorithms/deterministic.py, lines 105–221 · score 0.63 · seed points, implement tractography, OpenCL, vertices, propagation, probabilistic
  10. [10] § Recent Applications › Local tractography ↔ catractography.py, lines 208–317 · score 0.63 · diffusion MRI, DIPY, fiber orientation, CSD, library, weighted
  11. [11] § Recent Applications › ODF reconstruction ↔ mdt/lib/fsl_sampling_routine.py, lines 12–79 · score 0.61 · Markov chain Monte, Carlo, MCMC, algorithm, modeling
  12. [12] § Recent Applications › Global and geodesic tractography ↔ CA_on_HCPSubject.py, lines 63–126 · score 0.60 · cellular automata, HCP subjects, CA, iteratively, fits, connectivity
  13. [13] § Recent Applications › Streamline post-processing ↔ mdt/models/composite.py, lines 40–123 · score 0.55 · Optimization Modeling, compartment model, Spherical, vector, signal, post
  14. [14] § Recent Applications › Global and geodesic tractography ↔ anatomist-plugin/src/command/GkgDwiGlobalTractographyViewer/Old/GlobalTractographyService.h, lines 25–82 · score 0.54 · spin glass, Global tractography, deletion, creation, optimization, connect
  15. [15] § Recent Applications › Global and geodesic tractography ↔ anatomist-plugin/src/command/GkgDwiGlobalTractographyViewer/GlobalTractographyService.h, lines 24–85 · score 0.53 · spin glass, Global tractography, deletion, creation, connect
  16. [16] § Recent Applications › Streamline post-processing ↔ life/fe/feCreate.m, the whole file · a weak match · score 0.52 · Linear Fascicle Evaluation, sparse, matrix, signal, algorithms
  17. [17] § Recent Applications › Local tractography ↔ tractography/algorithms/probabilistic.py, lines 106–232 · score 0.52 · probabilistic algorithms, probabilistic tractography, angle, seed, Streamlines, orientations
  18. [18] § The Case for Massively Parallel Tractography ↔ scripts/demos/demo_virtual_lesion.m, lines 1–137 · score 0.51 · white matter tract, reliable, Human, candidate, properties, reproducibility

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 · 319 lines · 14 KB · GPL-3.0 · 2 matches

  1. # -*- coding: utf-8 -*-
  2. """ Cellular Automata Tractography: Fast Geodesic Diffusion MR Tractography and Connectivity Based Segmentation on the GPU
  3. Copyright (C) 2019 Andac Hamamci
  5. This program is free software: you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation, either version 3 of the License, or
  8. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with this program. If not, see <https://www.gnu.org/licenses/>.
  18. Andac Hamamci
  19. [email hidden]
  21. """
  23. # -----------------------
  24. # COMPATIBILITY TESTED ON
  25. # -----------------------
  26. # DIPY version 1.2.0
  27. # Numpy version 1.18.5
  28. # pyopencl version 2020.2.2
  29. # Nibabel 3.2.0
  30. # -----------------------
  32. import numpy as np
  33. import os
  35. import nibabel as nib
  37. from dipy.io import read_bvals_bvecs
  38. from dipy.io.image import load_nifti
  39. from dipy.core.gradients import gradient_table
  40. from dipy.data import get_sphere
  41. from dipy.reconst.csdeconv import auto_response_ssst
  42. from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel
  43. from dipy.direction import peaks_from_model
  45. import pyopencl as cl
  47. class CATractography:
  48. def __init__(self):
  49. os.environ['PYOPENCL_COMPILER_OUTPUT'] = '1'
  51. self.ctx = cl.create_some_context(interactive=True)
  52. self.queue = cl.CommandQueue(self.ctx)
  54. self.ngpuprocs = 0
  56. # Using UINT32 type for the label variable resulted 32bits/64bits confusion.
  57. # I couldn't arrange the pointers in a correct way so the labels are also float. Andac
  59. self.prg = cl.Program(self.ctx, """
  60. __kernel void gpuca(__global float *label, __global float *nlabel, __global float *strn, __global float *nstrn, __global float *dist, __global float *ndist, __global const int *nbr, __global const float *nbrdist, __global const int *shape)
  61. {
  62. int pid = get_global_id(0);
  63. int idx = pid / (shape[1]*shape[2]);
  64. int idy = (pid - idx*shape[1]*shape[2])/shape[2];
  65. int idz = pid - idx*shape[1]*shape[2] - idy*shape[2];
  67. int nbrx,nbry,nbrz,nbrid,nbrdistid,nb;
  68. if ( (idx>0) && (idx<shape[0]-1) && (idy>0) && (idy<shape[1]-1) && (idz>0) && (idz<shape[2]-1) )
  69. {
  70. for(nb=0; nb<shape[3]; nb++)
  71. {
  72. nbrx = idx + nbr[3*nb];
  73. nbry = idy + nbr[3*nb+1];
  74. nbrz = idz + nbr[3*nb+2];
  76. nbrid = nbrx * shape[1] * shape[2] + nbry * shape[2] + nbrz;
  77. nbrdistid = pid*shape[3]+nb;
  79. if (nstrn[pid] < strn[nbrid]*nbrdist[nbrdistid])
  80. {
  81. nlabel[pid] = label[nbrid];
  82. nstrn[pid] = strn[nbrid]*nbrdist[nbrdistid];
  83. ndist[pid] = dist[nbrid]+1;
  84. }
  85. }
  86. }
  87. }
  88. """).build()
  90. def set_gpu_variables(self,seed):
  91. self.label = np.zeros(seed.shape, dtype=np.float32)
  92. for i in range(seed.shape[0]):
  93. for j in range(seed.shape[1]):
  94. for k in range(seed.shape[2]):
  95. self.label[i,j,k] = np.float32(seed[i,j,k])
  97. self.ngpuprocs = (np.prod(self.label.shape),1)
  99. mf = cl.mem_flags
  100. self.gpu_label = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.label)
  101. self.gpu_nlabel = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.label)
  103. self.strn = np.zeros(seed.shape, dtype=np.float32)
  104. self.strn[seed>0] = 1.0
  105. self.gpu_strn = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.strn)
  106. self.gpu_nstrn = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.strn)
  108. self.dist = np.zeros(seed.shape, dtype=np.float32)
  109. self.dist[:,:,:] = 1.0
  110. self.gpu_dist = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.dist)
  111. self.gpu_ndist = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=self.dist)
  113. def set_gpu_graph(self,nbh_pdf,nbh):
  114. mf = cl.mem_flags
  115. self.gpu_nbh = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=nbh)
  116. self.gpu_nbh_w = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=np.float32(nbh_pdf))
  118. nbh_w_shape = np.int32(nbh_pdf.shape)
  119. self.gpu_nbh_w_shape = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=nbh_w_shape)
  121. def gpu_one_iteration(self):
  122. self.prg.gpuca(self.queue, self.ngpuprocs, None, self.gpu_label, self.gpu_nlabel, self.gpu_strn, self.gpu_nstrn, self.gpu_dist, self.gpu_ndist, self.gpu_nbh, self.gpu_nbh_w, self.gpu_nbh_w_shape)
  123. tmp = self.gpu_label
  124. self.gpu_label = self.gpu_nlabel
  125. self.gpu_nlabel = tmp
  126. tmp = self.gpu_strn
  127. self.gpu_strn = self.gpu_nstrn
  128. self.gpu_nstrn = tmp
  129. tmp = self.gpu_dist
  130. self.gpu_dist = self.gpu_ndist
  131. self.gpu_ndist = tmp
  133. def get_gpu_variables(self):
  134. cl.enqueue_copy(self.queue, self.label, self.gpu_label)
  135. cl.enqueue_copy(self.queue, self.strn, self.gpu_strn)
  136. cl.enqueue_copy(self.queue, self.dist, self.gpu_dist)
  137. self.conn = self.strn**(1/self.dist)
  139. def gpu_N_iterations(self,NIterations=70):
  140. for i in range(NIterations):
  141. self.gpu_one_iteration()
  144. def create_graph(csd_odf, sphere, tissueprior):
  146. # All 26 directions are defined.
  147. nbh=np.array([[1,0,0],[0,1,0],[1,1,0],[1,-1,0],[-1,1,0],[-1,0,0],[0,-1,0],[-1,-1,0],[-1,0,-1],[0,0,1],[0,-1,-1],[0,0,-1],[-1,-1,-1],[-1,0,1],[0,1,-1],[0,-1,1],[1,1,-1],[-1,1,1],[1,0,1],[0,1,1],[1,1,1],[1,-1,1],[1,0,-1],[-1,-1,1],[-1,1,-1],[1,-1,-1]],dtype=np.int32)
  149. # Transform 724 directions to 26 directions for every voxels.
  150. # Find the minimum angle value by calculating the angle between
  151. # the vector in 724 direcitons and the vector in 26 directions.
  152. # This transformation data is saved in transform[] array.
  153. transform=np.zeros(sphere.theta.shape[0],dtype=np.int32)
  154. fnbh = np.float32(nbh)
  155. for i in range(0,sphere.theta.shape[0]):
  156. min_ang=360
  157. for j in range(0,nbh.shape[0]): #26 neighborhoods
  158. dot=(fnbh[j,0]*sphere.x[i]+fnbh[j,1]*sphere.y[i]+fnbh[j,2]*sphere.z[i])/(np.linalg.norm(fnbh[j,:]))
  159. ang=np.arccos(dot)
  161. if min_ang>ang:
  162. min_ang=ang
  163. transform[i]=j
  164. transform = np.int32(transform)
  166. nbh_pdf=np.zeros((csd_odf.shape[0],csd_odf.shape[1],csd_odf.shape[2],nbh.shape[0]),dtype=np.float32)
  168. # In this part, we trasnform odf's from 724 directions
  169. # to distrubuted 26 directions. Then we normalize the ODF's for all voxels.
  170. for k in range(0,csd_odf.shape[0]):
  171. for m in range(0,csd_odf.shape[1]):
  172. for sl in range(0,csd_odf.shape[2]):
  173. for i in range(0,sphere.theta.shape[0]):
  174. nbh_pdf[k,m,sl,transform[i]]+=csd_odf[k,m,sl,i]
  176. if (np.sum(nbh_pdf[k,m,sl,:])<0.0001):
  177. nbh_pdf[k,m,sl,:]=0
  178. else:
  179. nbh_pdf[k,m,sl,:]=(nbh_pdf[k,m,sl,:]/np.max(nbh_pdf[k,m,sl,:]))
  180. #22/3/2018: Scale maximum to 0.5 (Instead of normalizing to 1) see: medina2007
  181. #06/06/2020: There is a mistake. If 0.5 used here, should not be divided by 2 when averaging.
  183. #Obtain a symmetric edge weighting
  184. negnbh = np.zeros(nbh.shape[0],dtype=np.int32)
  185. for i in range(nbh.shape[0]):
  186. for j in range(nbh.shape[0]):
  187. if np.all(-nbh[i] == nbh[j]):
  188. negnbh[i]=j
  190. for d in range(0,nbh_pdf.shape[3]):
  191. #we will take only one of the directions to prevent double count
  192. if (negnbh[d]>d):
  193. for i in range(1,nbh_pdf.shape[0]-1):
  194. for j in range(1,nbh_pdf.shape[1]-1):
  195. for k in range(1,nbh_pdf.shape[2]-1):
  196. cur = (i,j,k)
  197. other = tuple(cur+nbh[d])
  198. otherd = negnbh[d]
  199. # No need to use tissue priors. Andac
  200. newval = tissueprior[cur] * tissueprior[other] * 0.5 * (nbh_pdf[cur][d] + nbh_pdf[other][otherd]) #averaging is problematic
  201. #newval = 0.5 * (nbh_pdf[cur][d] + nbh_pdf[other][otherd])
  202. nbh_pdf[cur][d] = newval
  203. nbh_pdf[other][otherd] = newval
  205. nbh_pdf[nbh_pdf<0]=0
  206. return nbh_pdf, nbh
  208. def fit_csd_model(data_file, bval_file, bvec_file, sh_order=8, UseMemoryEfficiently=True, UseParallel=True, Print_Response=False, roi_radius=10, fa_thr=0.7):
  209. """ Calculate the fiber orientation distribution function (fODF)
  210. Uses DIPY library
  212. Parameters
  213. ----------
  214. data_file : File name of the diffusion weighted data in NII format.
  215. bval_file : File name of the bval file.
  216. Text file listing b-values of each volume in the dataset.
  217. bvec_file : File name of the bvec file.
  218. Text file listing diffusion gradient directions
  219. of each volume in the dataset.
  220. sh_order : Spherical harmonic order for CSD. Try lower values (4,6...) if the fit fails for low number of directions.
  221. Print_Response : Print detailed information on the estimated fiber response function
  223. Returns
  224. -------
  225. csd_odf : numpy array
  226. sphere : dipy.core.sphere.Sphere object
  228. Notes
  229. -----
  231. References
  232. ----------
  233. .. [1] Tournier, J.D., et al. NeuroImage 2007. Robust determination of
  234. the fibre orientation distribution in diffusion MRI:
  235. Non-negativity constrained super-resolved spherical
  236. deconvolution
  237. """
  239. bvals,bvecs = read_bvals_bvecs(bval_file,bvec_file)
  240. gtab = gradient_table(bvals, bvecs)
  241. img = nib.load(data_file)
  243. sphere = get_sphere('symmetric724')
  245. # ESTIMATION OF THE FIBRE RESPONSE FUNCTION ###################################
  246. # The auto_response function will calculate FA for an ROI of radius equal to roi_radius
  247. # in the center of the volume and return the response function estimated in that region
  248. # for the voxels with FA higher than 0.7.
  250. data, affine = load_nifti(data_file)
  251. response, ratio = auto_response_ssst(gtab, data, roi_radii=roi_radius, fa_thr=fa_thr)
  253. if (Print_Response):
  254. print('------------------------------------------------------------------------------------------------')
  255. print('Response Function = ' + str(response))
  256. print('Ratio = ' + str(ratio) + '[value should be about 0.2]')
  257. print('------------------------------------------------------------------------------------------------')
  258. print('The tensor generated from the response must be prolate (two smaller eigenvalues should be equal)')
  259. print('and look anisotropic with a ratio of second to first eigenvalue of about 0.2.')
  260. print('Or in other words, the axial diffusivity of this tensor should be around 5 times larger than the')
  261. print('radial diffusivity.')
  262. print('------------------------------------------------------------------------------------------------')
  264. csd_model = ConstrainedSphericalDeconvModel(gtab,response,sh_order=sh_order)
  266. if UseParallel:
  267. if (UseMemoryEfficiently):
  268. csd_odf = np.zeros((img.shape[0],img.shape[1],img.shape[2],sphere.phi.shape[0]),dtype=np.float32)
  269. slimg = np.zeros((img.shape[0],img.shape[1],1,img.shape[3]))
  270. for sl in range(0,img.shape[2]):
  271. print('processing slice ' + str(sl+1) + ' of ' + str(img.shape[2]) )
  272. slimg[:,:,0,:] = img.dataobj[:,:,sl,:]
  273. tmp_csd_fit = peaks_from_model(model=csd_model,
  274. data=slimg,
  275. sphere=sphere,
  276. relative_peak_threshold=.5,
  277. min_separation_angle=25,
  278. mask=None,
  279. return_sh=False,
  280. return_odf=True,
  281. normalize_peaks=False,
  282. npeaks=5,
  283. parallel=True,
  284. nbr_processes=None)
  286. csd_odf[:,:,sl,:] = np.squeeze(tmp_csd_fit.odf)
  287. else:
  288. tmp_csd_fit = peaks_from_model(model=csd_model,
  289. data=img.get_data(),
  290. sphere=sphere,
  291. relative_peak_threshold=.5,
  292. min_separation_angle=25,
  293. mask=None,
  294. return_sh=False,
  295. return_odf=True,
  296. normalize_peaks=False,
  297. npeaks=5,
  298. parallel=True,
  299. nbr_processes=None)
  301. csd_odf = np.squeeze(tmp_csd_fit.odf)
  302. else:
  303. if (UseMemoryEfficiently):
  304. # Do CSD fit slice by slice to use memory efficiently in processing big data (such as HCP)
  305. csd_odf = np.zeros((img.shape[0],img.shape[1],img.shape[2],sphere.phi.shape[0]),dtype=np.float32)
  306. slimg = np.zeros((img.shape[0],img.shape[1],1,img.shape[3]))
  307. for sl in range(0,img.shape[2]):
  308. print('processing slice ' + str(sl+1) + ' of ' + str(img.shape[2]) )
  309. slimg[:,:,0,:] = img.dataobj[:,:,sl,:]
  310. tmp_csd_fit = csd_model.fit(slimg)
  311. csd_odf[:,:,sl,:] = np.squeeze(tmp_csd_fit.odf(sphere))
  312. else:
  313. csd_fit = csd_model.fit(img.get_data())
  314. csd_odf = csd_fit.odf(sphere)
  316. #csd_odf = csd_odf.clip(min=0) #consumes too much memory
  317. return csd_odf, sphere

catractography.py at commit 3436ad3, under GPL-3.0 · at the source

Overview

Authors: John Kruper1, Ariel Rokem2,3
ORCID iDs: John Kruper, Ariel Rokem
  1. Department of Psychology, University of Washington, Seattle, WA, United States
  2. Krembil Centre for Neuroinformatics, Campbell Family Mental Health Research Institute, Centre for Addiction and Mental Health, Toronto, ON, Canada
  3. Department of Psychiatry, University of Toronto, Toronto, ON, Canada
Institutions: University of Washington (United States); Centre for Addiction and Mental Health (Canada); University of Toronto (Canada); Campbell Family Mental Health Research Institute (Canada)
Journal: Imaging neuroscience (Cambridge, Mass.), volume 4, article IMAG.a.1341
Dates: received 1 January 2026; accepted 25 July 2026; published online 19 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1162/imag.a.1341 · PMID 42626657 · PMCID PMC13492401 · OpenAlex W7172288604
Open access: diamond, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), methods / tools (subfield)
Methods: Statistics, Machine learning, Graphs, fMRI & imaging, Physiology & signal measures
Keywords: tractography, graphics processing units, high performance computing, diffusion MRI
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: NIA NIH HHS (R01 AG060942, U19 AG066567); NIMH NIH HHS (RF1 MH121867, R01 MH126699, RF1 MH121868); NEI NIH HHS (R01 EY033628); NIBIB NIH HHS (R01 EB027585)
Citations: not cited yet (Europe PMC); 149 references in the paper

Abstract

Tractography based on diffusion-weighted MRI (dMRI) is the predominant in vivo method for mapping the brain’s white matter. However, it is also one of the most computationally demanding steps in neuroimaging data analysis—requiring the generation and filtering of millions of streamlines per subject. Over the past decade, high-performance computing (HPC) and graphics processing units (GPUs) have reshaped the landscape of tractography. What once required hours or days per subject can now be performed in minutes or even seconds. This facilitates faster processing of large-scale studies and high-resolution datasets, supports real-time clinical applications, and enables more computationally demanding algorithms. This review surveys the recent wave of applications of HPC and GPUs to massively parallelize tractography. We discuss how these advances have accelerated tractography pipelines, identify common strategies for parallelization, and highlight opportunities where further parallelization could improve efficiency and accuracy.

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

Repositories

Its files are read in the Code ↔ Paper reader above, with 18 matches between paragraphs and lines of code.

gitlab.inria.fr/cronos/software/tractography

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 2138a9ef7b5d8f2e2df19c9e4ab9c65209de3f5c, 3 December 2025
Languages: Python (41)
Size: 64 files, 41 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, environment (pyproject.toml), tests, continuous integration
Not found: license file, CITATION.cff, documentation
Tools: NumPy (29 files), NiBabel (19 files), SciPy (5 files)
Availability: 2 checks, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
  • 27 September 2026: unreachable at the last attempt
42 files
At the source: gitlab.inria.fr/cronos/software/tractography

cronos-inria/Tractography.jl

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6cd5edbabb870bc0deadeecd6d048e88f6efb968, 16 August 2026
Languages: Julia (25)
Size: 54 files, 25 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file, environment (Project.toml, docs/Project.toml), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: Makie (4 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
27 files
At the source: github.com/cronos-inria/Tractography.jl

karanaggarwal1994/life-opt

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0bc7f206f49ceec1b259d6efa04b7249e0d12487, 30 January 2020
Languages: MATLAB (5), C++ (4), C/C++ (2), CUDA (1)
Size: 14 files, 12 scripts
Software Heritage: archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Parallel Computing Toolbox (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
14 files
At the source: github.com/karanaggarwal1994/life-opt

arcosuc3m/phardi

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 58e26b91129e249334fa0b89115ddaee9578006e, 6 June 2018
Languages: C/C++ (15), C++ (1)
Size: 63 files, 16 scripts
Software Heritage: archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
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/arcosuc3m/phardi

shashankgugnani/encode

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6339db7eeb227d026fb069fb4e5f06c4c7c2f519, 25 April 2019
Languages: MATLAB (322), C (10), C/C++ (5)
Size: 387 files, 337 scripts
Software Heritage: archived
Found in: “Software metadata for massively parallel tractog”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (5 files), Brain Connectivity Toolbox (1 file), Optimization Toolbox (1 file), Parallel Computing Toolbox (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
338 files
At the source: github.com/shashankgugnani/encode

andachamamci/CATractography

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3436ad351efce7ea261d16c4d35e4238a271f377, 5 May 2022
Languages: Python (8)
Size: 20 files, 8 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NiBabel (8 files), NumPy (8 files), DIPY (6 files), SciPy (3 files), Matplotlib (2 files), Nilearn (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
10 files
At the source: github.com/andachamamci/CATractography

robbert-harms/MDT

License: LGPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6a801c9bfef1b2ca6f477e399616eabd1efeb63e, 4 March 2024
Languages: Python (187)
Size: 318 files, 187 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file, environment (requirements.txt, requirements_documentation.txt, requirements_tests.txt, setup.cfg, setup.py, containers/Dockerfile.intel, containers/Dockerfile.nvidia, containers/Singularity.intel), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: NumPy (47 files), Matplotlib (8 files), SciPy (3 files), NiBabel (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
189 files
At the source: github.com/robbert-harms/MDT

SPMIC-UoN/cudimot

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 5f9e4ff1bbb8f08de1a7e25f988ed7e0b62072fd, 17 November 2025
Languages: C/C++ (75), Shell (51), C++ (27), Python (20), CUDA (10)
Size: 213 files, 183 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file, environment (python/requirements.txt, python/setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: FSL (48 files), NiBabel (3 files), NumPy (3 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
185 files
At the source: github.com/SPMIC-UoN/cudimot

daducci/commit

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 014228d8fbe2b729534dbdc54bd7830c9f251bab, 5 August 2026
Languages: C/C++ (32), Python (6), C++ (1)
Size: 67 files, 39 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file, environment (pyproject.toml, requirements.txt, setup.py), tests, continuous integration
Not found: CITATION.cff, documentation
Tools: NumPy (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
41 files
At the source: github.com/daducci/COMMIT/pull/83

jzxu0622/mati

License: BSD-2-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 425c89e4c3b3d91e2a70c53153e36818326d0322, 4 May 2025
Size: 4 files, 0 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/jzxu0622/mati

framagit.org/cpoupon/gkg

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: d1669f8d9da159e1372e18dcd9d8cb6da9d3660b, 3 September 2026
Languages: C/C++ (2575), Python (72), C++ (46), Shell (15), CUDA (1)
Size: 5,430 files, 2,709 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: license file, tests
Not found: README, CITATION.cff, environment file, continuous integration, documentation
Tools: Matplotlib (1 file)
Availability: 2 checks, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
  • 27 September 2026: unreachable at the last attempt
2,000 files
At the source: framagit.org/cpoupon/gkg

CHrlS98/aodf-toolkit

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: b5dbaf1d1d87736a90d6b6a9d8587773566f5893, 18 April 2024
Languages: Python (11)
Size: 19 files, 11 scripts
Software Heritage: not archived
Found in: “Software metadata for massively parallel tractog”
Holds: README, license file, environment (pyproject.toml, setup.cfg)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (6 files), DIPY (4 files), NiBabel (2 files), Numba (1 file), pandas (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
13 files
At the source: github.com/CHrlS98/aodf-toolkit

codeocean:7377624

License: none: the authors keep all their rights
State: cannot be verified, verified on 27 September 2026
Evidence: found in the paper
Software Heritage: not checked
Found in: “Software metadata for massively parallel tractog”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: cannot be verified
  • 27 September 2026: cannot be verified
At the source: codeocean.com/capsule/7377624/tree/v1

Software availability

In Table 5, we list all software since 2015 for massively parallelized tractography based on the criteria listed in Section 2.1. This excludes software focused solely on single CPU acceleration, neural networks, or visualization. Yoo et al. (2015) and Labra et al. (2017) were excluded because we could not find the associated code online. In contrast to work published before 2015, most HPC and GPU tractography papers since have made their source code publicly accessible online. This represents a positive development for the field and a significant step toward reproducible and transparent research.

While the tools listed in Table 5 are largely open-source, active maintenance status varies. Long-term software sustainability remains a significant challenge; the lack of dedicated funding and professional incentives for maintenance frequently results in technical debt, potentially rendering specialized high-performance tools obsolete or unusable (Connolly et al., 2023). Most tools exhibit a limited active maintenance window of 2 to 3 years following their primary publication. Two notable exceptions are the Microstructure Diffusion Toolbox (MDT), published in 2017, and cuDIMOT, published in 2019, which are both still maintained as of this writing. All software can benefit from providing containerized environments such as Docker or Singularity, as these allow reproducible deployment even years after publishing. This is particularly important for massively parallel neuroimaging pipelines because they can require specific versions of system drivers alongside their neuroimaging dependencies.

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:

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

This review did not generate new data or code. All software packages discussed are publicly available at the repositories listed in Table 5.

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, 2 authors, 4 keywords, 4 funders, 141 references.

Cite

This paper

Kruper, J., & Rokem, A. (2026). Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units. Imaging neuroscience (Cambridge, Mass.), 4, IMAG.a.1341. https://doi.org/10.1162/imag.a.1341

BibTeX

@article{kruper2026massively,
author = {Kruper, John and Rokem, Ariel},
title = {{Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units}},
journal = {Imaging neuroscience (Cambridge, Mass.)},
year = {2026},
month = aug,
volume = {4},
pages = {IMAG.a.1341},
publisher = {MIT Press},
issn = {2837-6056},
doi = {10.1162/imag.a.1341},
url = {https://doi.org/10.1162/imag.a.1341},
pmid = {42626657},
pmcid = {PMC13492401}
}

RIS

TY - JOUR
AU - Kruper, John
AU - Rokem, Ariel
TI - Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units
T2 - Imaging neuroscience (Cambridge, Mass.)
J2 - Imaging Neurosci (Camb)
PY - 2026
DA - 2026/08/19
VL - 4
SP - IMAG.a.1341
SN - 2837-6056
PB - MIT Press
DO - 10.1162/imag.a.1341
UR - https://doi.org/10.1162/imag.a.1341
LA - en
ER -

CSL-JSON

{
"id": "10.1162/imag.a.1341",
"type": "article-journal",
"title": "Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units",
"container-title": "Imaging neuroscience (Cambridge, Mass.)",
"author": [
{
"family": "Kruper",
"given": "John"
},
{
"family": "Rokem",
"given": "Ariel"
}
],
"container-title-short": "Imaging Neurosci (Camb)",
"volume": "4",
"page": "IMAG.a.1341",
"DOI": "10.1162/imag.a.1341",
"PMID": "42626657",
"PMCID": "PMC13492401",
"ISSN": "2837-6056",
"publisher": "MIT Press",
"URL": "https://doi.org/10.1162/imag.a.1341",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
19
]
]
}
}

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.1038/s41467-026-73366-9 [code]
Cortical and white matter myelination proceed in concert during early infancy.
Journal: Nature communications
In common: DIPY, NiBabel, pandas, 3 other tools, 5 references, 2 authors
[2] doi:10.1016/j.isci.2026.116671 [code]
A high-resolution functional network-organized atlas of human superficial white matter from ultra-high-field diffusion MRI.
Journal: iScience
In common: DIPY, FSL, Nilearn, 6 other tools, methods / tools, structural MRI / diffusion, 5 references
[3] doi:10.1038/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: Brain Connectivity Toolbox, Optimization Toolbox, Numba, 9 other tools, 1 reference
[4] doi:10.1186/s12916-026-04770-7 [code]
Impairment of brain short association fibers across clinical stages in amyotrophic lateral sclerosis: a new biomarker mirroring disease progression.
Journal: BMC medicine
In common: DIPY, FSL, NiBabel, 4 other tools, structural MRI / diffusion, 6 references
[5] doi:10.1002/mrm.70336 [code]
Offline Reconstruction of Diffusion MRI Acquisitions for Comparison Between Complex PCA-Based and AI-Based Denoising.
Journal: Magnetic resonance in medicine
In common: DIPY, Optimization Toolbox, Parallel Computing Toolbox, 7 other tools, methods / tools, structural MRI / diffusion, 2 references
[6] doi:10.1038/s41467-026-74466-2 [code]
Neuromorphic hierarchical modular reservoirs.
Journal: Nature communications
In common: Brain Connectivity Toolbox, Numba, Nilearn, 5 other tools, 4 references
[7] doi:10.1038/s41467-026-73072-6 [code]
Mapping the spatiotemporal continuum of structural connectivity development across the human connectome in youth.
Journal: Nature communications
In common: NiBabel, pandas, NumPy, structural MRI / diffusion, 9 references
[8] doi:10.7554/elife.103097 [code]
Canonical neurodevelopmental trajectories of structural and functional manifolds.
Journal: eLife
In common: Brain Connectivity Toolbox, Nilearn, NiBabel, 4 other tools, structural MRI / diffusion, 5 references
[9] doi:10.1002/nbm.70277 [code]
Hierarchical Bayesian Modelling Improves Microstructural Parameter Mapping in Diffusion and Exchange MRI Data.
Journal: NMR in biomedicine
In common: DIPY, Optimization Toolbox, Parallel Computing Toolbox, 5 other tools, structural MRI / diffusion, 3 references
[10] doi:10.1162/imag.a.1153 [code]
TRAMFIX: TRavelling Across Melbourne for FIXel-based analysis (a reproducibility and reliability study).
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: FSL, pandas, SciPy, 2 other tools, methods / tools, structural MRI / diffusion, 6 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.

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.