OSCR

SimulScan and Partial Least Squares: Visualizing Swallowing Through Functional and Dynamic Imaging Correlations.

Code ↔ Paper

1 match 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 1 match
  1. [1] § Results ↔ plsc.ipynb, lines 1–33 · score 0.62 · motion correction, MRI images, FSL, filtering, fMRI, SimulScan

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 · 358 lines · 11 KB · no license · 1 match

  1. # %% [markdown]
  2. # ## Partial Least Squares Correlation (PLSC) of SimulScan data
  3. #
  4. # PLSC is a two-part analysis:
  5. # - First, we prepare our input variables, **X** (fMRI) and **Y** (dynamic MRI)
  6. # - Second, we perform a singular value decomposition (SVD) and calculate the latent variables
  7. #
  8. # This notebook performs the full analysis of a subset of data used in the paper, MRISSB_007/Run1.
  10. # %%
  11. from pathlib import Path
  13. import numpy as np
  14. from scipy.stats import gamma
  16. from utilities.BoundingBox import BoundingBox
  17. from utilities.MatlabFile import MatlabFile
  18. from utilities.NiftiFile import NiftiFile
  19. from utilities.NPFile import NPFile
  20. from utilities.PathHelper import PathHelper
  21. from utilities.ROIPlot import ROIPlot
  23. # Public tutorial data: MRISSB_007/Run1, slice 8.
  24. DATA_DIR = Path("./tutorial_data")
  26. # FSL motion-corrected fMRI data
  27. fmri_path = str(DATA_DIR / "filtered_func_data.nii.gz")
  29. # two inputs for constructing dynamic MRI image
  30. temp_bas_path = str(DATA_DIR / "temp_bas.mat")
  31. uu_path = str(DATA_DIR / "UU.mat")
  33. results_dir = PathHelper.resolve_directory("plsc_results")
  35. # %%
  36. # use custom utilities to load in Nifti and Matlab files into Python Numpy data structures
  38. fmri = NiftiFile.read(fmri_path)
  40. # load components of dynamic image
  41. temp_bas = MatlabFile.read(temp_bas_path, data_key="temp_bas")
  42. uu = MatlabFile.read(uu_path, data_key="UU")
  44. # %%
  45. # construct dynamic image F from constituents
  46. number_of_time_points = len(temp_bas)
  48. # calculates the dynamic swallow of the mid-sagittal
  49. dyn_img_raw_calculation = uu @ temp_bas.conj().T
  51. dyn_image_dimensions = int(np.sqrt(dyn_img_raw_calculation.shape[0])) # images are 92x92, 225x225, etc
  53. print(f"Dynamic image dimensions: {dyn_image_dimensions}")
  55. F = np.reshape(
  56. dyn_img_raw_calculation,
  57. (dyn_image_dimensions, dyn_image_dimensions, 1, number_of_time_points),
  58. order="F",
  59. )
  61. print(f"{F.shape=}")
  63. # %%
  64. # reshape fmri into 2D
  65. fmri_copy = np.copy(fmri)
  67. fmri_x, fmri_y, num_slices = fmri_copy.shape[:3]
  69. # MATLAB arrays are stored in memory as column-major ("F" => "fortran" order). Python is row-major
  70. reshaped_functional_img = fmri_copy.reshape(fmri_x * fmri_y * num_slices, -1, order="F")
  72. print(f"{reshaped_functional_img.shape=}")
  74. # %%
  75. dyn_x, dyn_y, _, dyn_z = F.shape
  77. reshaped_dynamic_img = np.reshape(np.absolute(F), (dyn_x, dyn_y, num_slices, dyn_z // num_slices), order="F")
  79. print(f"{reshaped_dynamic_img.shape=}")
  81. # %%
  82. # calculate std of dyn image along time axis to visualize
  83. dynamic_std_map = np.std(np.squeeze(F), axis=2)
  85. print(f"{dynamic_std_map.shape=}")
  87. # %%
  88. def to_viewable(raw_img: np.ndarray) -> np.ndarray:
  89. # rotate raw image to convention, with superior aspect of skull at top of screen
  90. # and patient facing to the right
  92. return np.fliplr(np.rot90(raw_img, k=-1))
  95. # select bounding box to limit dynamic image input to SVD
  96. # we try to encompass all of the mid-sagittal swallow
  97. x0, y0 = (120, 130)
  98. x1, y1 = (202, 210)
  100. # construct BBox object, which contains several helpful utitlity methods
  101. roi = BoundingBox(x0, x1, y0, y1)
  103. roi_plot = ROIPlot(image_arr=to_viewable(dynamic_std_map), roi=roi)
  104. roi_plot.show()
  106. print(f"Hashed roi str: {roi.hash=}")
  108. # %%
  109. def scale_arr(arr: np.ndarray, max_value: float = (2**8 - 1)) -> np.ndarray:
  110. """scale all values to between 0 and `max_value`"""
  112. return (arr - arr.min()) * (1 / (arr.max() - arr.min()) * max_value)
  115. # create sub dir for roi-specific results
  116. PathHelper.resolve_directory(results_dir, roi.hash)
  118. roi_plot.write_plot(save_file_location=PathHelper.resolve_file_path(results_dir, roi.hash, "dynaming_img_roi.png"))
  120. NPFile.write_image(
  121. to_viewable(scale_arr(dynamic_std_map).astype("uint8")),
  122. destination_filename=PathHelper.resolve_file_path(results_dir, roi.hash, "dynamic_display_img.png"),
  123. )
  125. # %%
  126. # sanity check to ensure we've selected the right region for further processing
  127. roi_plot.show_subplot()
  129. # %%
  130. # subset dynamic image volume on roi we selected above
  131. dynamic_img_subvolume = reshaped_dynamic_img[roi.x1 - 1 : roi.x2, roi.y1 - 1 : roi.y2, :, :]
  133. print(f"{dynamic_img_subvolume.shape=}")
  135. # %%
  136. def calculate_hrf(TR: float, step_count: int, a1: float, scale1: int, a2: float, scale2: int) -> np.ndarray:
  137. """Calculate the hemodynamic response function (HRF) using a difference of two gamma functions."""
  139. ttf = np.arange(0, step_count + 1) * TR
  141. return gamma.pdf(ttf, a=a1, scale=scale1) - (1 / 6) * gamma.pdf(ttf, a=a2, scale=scale2)
  144. TR = 1.6
  146. step_count = 18
  148. a1 = 6
  149. a2 = 16
  151. scale1 = 1
  152. scale2 = 1
  154. # hemodynamic response function
  155. hrf = calculate_hrf(TR=TR, step_count=step_count, a1=a1, scale1=scale1, a2=a2, scale2=scale2)
  157. # %%
  158. # take sqrt of variance across dynamic image subvolume
  159. # For the public tutorial data, MRISSB_007/Run1 is reduced to slice 8 only;
  160. # with one slice, sample variance across slices is undefined, so use the
  161. # dynamic magnitude time series directly.
  162. if dynamic_img_subvolume.shape[2] == 1:
  163. dynamic_variance_img = np.squeeze(dynamic_img_subvolume, axis=2)
  164. else:
  165. dynamic_variance_img = np.sqrt(np.var(dynamic_img_subvolume, axis=2, ddof=1))
  167. x_range, y_range, z_range = dynamic_variance_img.shape
  169. for xx in range(x_range):
  170. for yy in range(y_range):
  171. tmp = np.convolve(np.squeeze(dynamic_variance_img[xx, yy, :]), hrf, mode="full")
  173. dynamic_variance_img[xx, yy, :] = tmp[:z_range]
  175. # reshape into an X•Y by Z volume
  176. dynamic_variance_img = dynamic_variance_img.reshape(x_range * y_range, z_range, order="F")
  178. SCALE_FACTOR = 1e6 # scale factor to bring values into a more reasonable range for SVD decomposition
  180. dynamic_variance_img = dynamic_variance_img * SCALE_FACTOR
  182. # %%
  183. # operands to the SVD must have the same number of time points, so we truncate to the shorter of the two
  184. time_point_truncation = min(dynamic_variance_img.shape[-1], reshaped_functional_img.shape[-1])
  186. print(f"Truncating dyn and func image to length: {time_point_truncation}")
  188. # %%
  189. # Truncate and transpose dynvar and func
  190. dynvar_trunc = dynamic_variance_img[:, :time_point_truncation].T
  191. func_trunc = np.abs(reshaped_functional_img[:, :time_point_truncation]).T
  193. # %%
  194. def center_and_normalize(matrix):
  195. column_means = np.mean(matrix, axis=0)
  196. column_squares = np.sum((matrix - column_means) ** 2, axis=0) # Sum of squares for centering
  198. centered_matrix = matrix - column_means
  200. normalized_matrix = centered_matrix / np.sqrt(column_squares)
  202. return np.nan_to_num(normalized_matrix, nan=0)
  205. # assume standard PLSC nomenclature, make deep copy
  206. x = np.copy(func_trunc) # predictor / brain
  207. y = np.copy(dynvar_trunc) # response / behavioral
  209. assert y.shape[0] == x.shape[0] # must have have same number of time points
  211. print(f"{y.shape=}")
  212. print(f"{x.shape=}")
  214. # determine bitmask for rows of X where the sum is nonzero
  215. x_mask_nonzero = ~(np.sum(x, axis=0) == 0)
  217. # these are the rows that sum to zero, save here so we can reconstruct
  218. # the full standardized X later on for latent variable analysis
  219. rows_zero_sum = x[:, ~x_mask_nonzero]
  221. # subset X to only include rows that sum to a nonzero value so we can
  222. # standardize it below
  223. x = x[:, x_mask_nonzero]
  225. # we center norm the fMRI and scale dynamic by its max
  226. x = center_and_normalize(x)
  227. y_scale = np.max(np.abs(y))
  229. if not np.isfinite(y_scale) or y_scale == 0:
  230. raise ValueError("Dynamic MRI matrix has no finite nonzero signal after preprocessing; check ROI and input data.")
  232. y = y / y_scale
  234. print(f"{y.shape=}")
  235. print(f"{x.shape=}")
  237. assert np.sum(np.isnan(y)) == 0 and np.sum(np.isnan(x)) == 0
  239. # %%
  240. R = np.dot(y.T, x)
  242. # %%
  243. from typing import Tuple
  245. import dask.array as da
  248. def svd(input_arr: np.ndarray, rank: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
  249. """
  250. returns svd results as (v, s, u)
  251. This particular svd implementation is optimized for large matrices, as used in our published
  252. methods. It is overkill for the small matrices used in this tutorial.
  253. """
  254. _u, _s, _v = da.linalg.svd_compressed(da.from_array(input_arr), k=rank, compute=True)
  256. u = np.asarray(_u.compute(), order="F")
  257. s = np.asarray(_s.compute(), order="F")
  258. v = np.asarray(_v.compute(), order="F")
  260. # u and v are swapped here to match the matlab svd
  261. # implementation
  262. return v, s, u
  265. SVD_RANK = 10
  267. _v, _s, _u = svd(R.T, rank=SVD_RANK)
  269. # %%
  270. from typing import Optional
  273. def mirror_diagonal(input_arr: np.ndarray, target_shape: Optional[Tuple[int, int]] = None) -> np.ndarray:
  274. """
  275. swap between row and column order precedence (ie convert an array into equivalent structure
  276. matlab <=> python)
  277. """
  278. effective_shape = target_shape
  280. if effective_shape is None:
  281. effective_shape = input_arr.shape
  283. return input_arr.T.reshape(effective_shape[::-1]).T
  286. # reorder matrices back to matlab paradigm
  287. u = MatlabFile.mirror_diagonal(_u, _u.shape)
  288. v = MatlabFile.mirror_diagonal(_v, _v.shape)
  289. s = MatlabFile.mirror_diagonal(_s, _s.shape)
  292. print(f"{u.shape=}")
  293. print(f"{v.shape=}")
  294. print(f"{s.shape=}")
  296. # %%
  297. def reconstruct_standardized_x(func_trunc, standardized_x, x_mask_nonzero, rows_zero_sum) -> np.ndarray:
  298. # RE-ADDING the zero-summed axis 0 indices
  299. X_reconstructed = np.zeros_like(func_trunc)
  301. # Place the filtered rows back in their original positions
  302. X_reconstructed[:, x_mask_nonzero] = standardized_x
  304. # Place the zero-sum rows back in their original positions
  305. X_reconstructed[:, ~x_mask_nonzero] = rows_zero_sum
  307. return X_reconstructed
  310. # re-add all zero-sum rows to `u`
  311. reconstructed_u = np.zeros(func_trunc.shape).T[:, :SVD_RANK]
  313. reconstructed_u[x_mask_nonzero, :] = u
  315. print(f"{u.shape=}")
  316. print(f"{reconstructed_u.shape=}")
  318. reconstructed_x = reconstruct_standardized_x(func_trunc, x, x_mask_nonzero, rows_zero_sum)
  320. # %%
  321. functional_component = np.zeros(func_trunc.shape)
  322. functional_component = functional_component[:SVD_RANK, :]
  323. functional_component[:, x_mask_nonzero] = u.T
  325. functional_component = np.transpose(functional_component, (1, 0))
  326. functional_component = np.reshape(functional_component, (fmri_x, fmri_y, num_slices, SVD_RANK), order="F")
  328. dynamic_component = np.transpose(v, (1, 0))
  329. dynamic_component = np.reshape(
  330. dynamic_component,
  331. [(roi.width + 1), (roi.height + 1), 1, SVD_RANK],
  332. order="F",
  333. )
  335. # construct the latent variables
  336. lx = reconstructed_x @ reconstructed_u # latent functional
  337. ly = y @ v.T # latent dyanmic
  339. print(f"{lx.shape=}, {ly.shape=}")
  341. # %%
  342. write_dir = PathHelper.resolve_directory(results_dir, roi.hash)
  345. def write_file(data, filename):
  346. NPFile.write(data, f"{write_dir}/{filename}")
  349. write_file(reconstructed_u, "u")
  350. write_file(v, "v")
  351. write_file(reconstructed_x, "x")
  352. write_file(y, "y")
  353. write_file(lx, "lx")
  354. write_file(ly, "ly")
  355. write_file(functional_component, "functional_components")
  356. write_file(dynamic_component, "dynamic_components")
  358. # now we can visualize these outputs in plsc_visualize.ipynb

plsc.ipynb at commit 39a20c9, no license · at the source

Overview

Authors: Bradley P Sutton1,2,3,4, Anthony Bosshardt1,3, Ching‐Hsuan Peng5, Ololade T Adetula1,2, Jiyoon Kim1,2,6, Riwei Jin1,6, Vaishnavi Krishna5, William G Pearson Jr7, Zhongming Liu8,9, Georgia A Malandraki5,10
ORCID iDs: Bradley P Sutton, Ching‐Hsuan Peng, Ololade T Adetula, Riwei Jin, William G Pearson Jr, Zhongming Liu, Georgia A Malandraki
  1. Beckman Institute for Advanced Science and Technology, University of Illinois Urbana Champaign, Urbana, Illinois, USA
  2. Department of Bioengineering, Grainger College of Engineering, University of Illinois Urbana Champaign, Urbana, Illinois, USA
  3. Carle Illinois College of Medicine, University of Illinois Urbana Champaign, Urbana, Illinois, USA
  4. Biohub Chicago, Chicago, Illinois, USA
  5. Department of Speech, Language, & Hearing Sciences, College of Health and Human Sciences, Purdue University, West Lafayette, Indiana, USA
  6. Coordinated Science Lab, University of Illinois Urbana Champaign, Urbana, Illinois, USA
  7. Department of Biomedical Sciences, Edward Via College of Osteopathic Medicine, Auburn, Alabama, USA
  8. Department of Biomedical Engineering, University of Michigan Ann Arbor, Ann Arbor, Michigan, USA
  9. Department of Electrical and Computer Engineering, University of Michigan Ann Arbor, Ann Arbor, Michigan, USA
  10. Department of Speech & Hearing Science, College of Applied Health Sciences, University of Illinois Urbana Champaign, Champaign, Illinois, USA
Institutions: University of Illinois Urbana-Champaign (United States); Chan Zuckerberg Biohub Chicago; Purdue University West Lafayette (United States); Edward Via College of Osteopathic Medicine (United States); University of Michigan (United States)
Journal: Magnetic resonance in medicine, volume 96, issue 4, pages 1755-1768
Dates: received 26 October 2025; accepted 6 June 2026; published online 21 June 2026; in print October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/mrm.70481 · PMID 42324631 · PMCID PMC13419336 · OpenAlex W7165538382
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: fMRI (modality), human (organism)
Methods: Connectivity, Complexity, fMRI & imaging, Smoothing, state filtering, decompositions
Keywords: dynamic MRI, functional analysis, functional MRI, swallowing
MeSH: Deglutition*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Adult, Algorithms, Biomechanical Phenomena, Brain, Female, Fluoroscopy, Humans, Image Interpretation, Computer-Assisted, Least-Squares Analysis, Male, Reproducibility of Results (* major topic)
Topic: Dysphagia Assessment and Management (Speech and Hearing, Health Professions), according to OpenAlex
Funding: NIH HHS (R01AG078513, S10 OD012336); National Institutes of Health (R01AG078513, S10 OD012336); NIA NIH HHS (R01 AG078513)
Citations: not cited yet (Europe PMC); 66 references in the paper

Abstract

Purpose: Swallowing involves the precise coordination of muscles and brain areas and can be disrupted in a variety of neurological conditions. Current methods to visualize swallowing cannot examine both the biomechanics and brain activity associated with specific swallowing events. An updated version of a pulse sequence that simultaneously samples BOLD‐based fMRI and dynamic imaging (called SimulScan) is introduced that provides higher quality and faster dynamic imaging, enabling data‐driven analysis of swallowing function through a partial least squares (PLS) analysis.

Methods: Integrating updated dynamic imaging approaches, SimulScan achieved dynamic MRI at 23.75 frames per second with a 30 cm field of view with BOLD fMRI at a 1.6 s TR. Five subjects were scanned with SimulScan twice and with videofluoroscopy to compare the preliminary reliability of measuring swallowing biomechanics using computational analysis of swallowing mechanics (CASM) and the test–retest relationship in correlated functional and dynamic components of PLS.

Results: High reliability of biomechanical measures of swallowing was achieved across the two SimulScan runs with CASM (r = 0.891; p < 0.0001) and between SimulScan and videofluoroscopy (r = 0.686; p < 0.0001). Correlations between dynamic and functional imaging across runs also showed high reliability (mean correlation of first 3 latent variable timeseries was 0.49 (p < 0.001) within a run and 0.17 (p < 0.001) across runs), indicating that SimulScan with PLS can extract reliable maps of linked correlations between the brain and the oropharyngeal dynamics.

Conclusion: The updated SimulScan with PLS analysis enables the study of central control of swallowing, providing simultaneous biomechanical visualization of the swallow along with brain functional signals.

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 1 match between paragraphs and lines of code.

mrfil/PLSCDemo

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 39a20c93452ddd759975901dd705cee9a4e8659d, 16 June 2026
Languages: Python (8), Jupyter (2)
Size: 17 files, 10 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, environment (pyproject.toml, requirements.txt), 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (7 files), Matplotlib (2 files), SciPy (2 files), h5py (1 file), NiBabel (1 file), Pillow (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
11 files
At the source: github.com/mrfil/PLSCDemo.git

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;
  • 10 scripts, each with its path and the digest of its content;
  • 1 match 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 that support the findings of this study are available on request from the corresponding author. The data are not publicly available due to privacy or ethical restrictions. Custom Python libraries were written to provide the PLS analysis and other processing leveraging Dask (www.dask.org), a python library for parallel computing. This script is available on GitHub (https://github.com/mrfil/PLSCDemo.git).

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

  • Publisher: n/a → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 10 authors, 4 keywords, 14 MeSH terms, 3 funders, 62 references.

Cite

This paper

Sutton, B. P., Bosshardt, A., Peng, C., Adetula, O. T., Kim, J., Jin, R., Krishna, V., Pearson, W. G., Liu, Z., & Malandraki, G. A. (2026). SimulScan and Partial Least Squares: Visualizing Swallowing Through Functional and Dynamic Imaging Correlations. Magnetic resonance in medicine, 96(4), 1755-1768. https://doi.org/10.1002/mrm.70481

BibTeX

@article{sutton2026simulscan,
author = {Sutton, Bradley P and Bosshardt, Anthony and Peng, Ching‐Hsuan and Adetula, Ololade T and Kim, Jiyoon and Jin, Riwei and Krishna, Vaishnavi and Pearson, William G and Liu, Zhongming and Malandraki, Georgia A},
title = {{SimulScan and Partial Least Squares: Visualizing Swallowing Through Functional and Dynamic Imaging Correlations}},
journal = {Magnetic resonance in medicine},
year = {2026},
month = jun,
volume = {96},
number = {4},
pages = {1755--1768},
publisher = {Wiley},
issn = {0740-3194},
doi = {10.1002/mrm.70481},
url = {https://doi.org/10.1002/mrm.70481},
pmid = {42324631},
pmcid = {PMC13419336}
}

RIS

TY - JOUR
AU - Sutton, Bradley P
AU - Bosshardt, Anthony
AU - Peng, Ching‐Hsuan
AU - Adetula, Ololade T
AU - Kim, Jiyoon
AU - Jin, Riwei
AU - Krishna, Vaishnavi
AU - Pearson, William G
AU - Liu, Zhongming
AU - Malandraki, Georgia A
TI - SimulScan and Partial Least Squares: Visualizing Swallowing Through Functional and Dynamic Imaging Correlations
T2 - Magnetic resonance in medicine
J2 - Magn Reson Med
PY - 2026
DA - 2026/06/21
VL - 96
IS - 4
SP - 1755
EP - 1768
SN - 0740-3194
PB - Wiley
DO - 10.1002/mrm.70481
UR - https://doi.org/10.1002/mrm.70481
LA - en
ER -

CSL-JSON

{
"id": "10.1002/mrm.70481",
"type": "article-journal",
"title": "SimulScan and Partial Least Squares: Visualizing Swallowing Through Functional and Dynamic Imaging Correlations",
"container-title": "Magnetic resonance in medicine",
"author": [
{
"family": "Sutton",
"given": "Bradley P"
},
{
"family": "Bosshardt",
"given": "Anthony"
},
{
"family": "Peng",
"given": "Ching‐Hsuan"
},
{
"family": "Adetula",
"given": "Ololade T"
},
{
"family": "Kim",
"given": "Jiyoon"
},
{
"family": "Jin",
"given": "Riwei"
},
{
"family": "Krishna",
"given": "Vaishnavi"
},
{
"family": "Pearson",
"given": "William G"
},
{
"family": "Liu",
"given": "Zhongming"
},
{
"family": "Malandraki",
"given": "Georgia A"
}
],
"container-title-short": "Magn Reson Med",
"volume": "96",
"issue": "4",
"page": "1755-1768",
"DOI": "10.1002/mrm.70481",
"PMID": "42324631",
"PMCID": "PMC13419336",
"ISSN": "0740-3194",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/mrm.70481",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
21
]
]
}
}

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/mrm.70429
Ultrafast fMRI Detects Age-Related Changes in Harmonics of Cardiac Pulsations in the Brain at 7 T.
Journal: Magnetic resonance in medicine
In common: fMRI, 4 references, author Bradley P Sutton
[2] doi:10.1162/netn.a.547 [code]
An evaluation of the efficacy of single-echo and multi-echo fMRI denoising strategies.
Journal: Network neuroscience (Cambridge, Mass.)
In common: NiBabel, SciPy, Matplotlib, 1 other tool, fMRI, 5 references
[3] 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: h5py, NiBabel, SciPy, 2 other tools, 4 references
[4] doi:10.1162/imag.a.1198 [code]
MEPrep: A robust pipeline for multi-echo fMRI denoising and preprocessing.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: h5py, NiBabel, SciPy, 2 other tools, fMRI, 3 references
[5] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: h5py, NiBabel, SciPy, 2 other tools, 3 references
[6] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: h5py, Pillow, NiBabel, 3 other tools, fMRI, 1 reference
[7] doi:10.1038/s41467-026-71428-6 [code]
Binding items to contexts through conjunctive neural representations with the method of loci.
Journal: Nature communications
In common: h5py, NiBabel, SciPy, 2 other tools, 3 references
[8] 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: Pillow, NiBabel, SciPy, 2 other tools, 3 references
[9] doi:10.1162/imag.a.1286 [code]
Behavioral imitation with artificial neural networks leads to personalized models of brain dynamics during videogame play.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: h5py, Pillow, NiBabel, 3 other tools, fMRI, 1 reference
[10] doi:10.1371/journal.pbio.3003755 [code]
Action information is integrated into entorhinal representations of conceptual space and is reflected in eye movements.
Journal: PLoS biology
In common: NiBabel, SciPy, Matplotlib, 1 other tool, 4 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.