OSCR

Spatial Entropy of Brain Network Landscapes: A Novel Method to Assess Spatial Disorder in Brain Networks.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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

MATLAB · 460 lines · 18 KB · no license

  1. function entropyCalc(niiFN, outFN, entropyMethod,scaleByDistanceFlag, scaleByModSizeFlag,scaleByPatchSize, distance, maskFN)
  2. %
  3. % Inputs
  4. %--------------------------------------------------------------------------
  5. % niiFN | nifti image
  6. % outFN | output image fn
  7. % entropyMethod | 1 = Shannon (Batty Voxel Adaptation)
  8. % | 2 = O'Neil
  9. % | 3 = Claramunt
  10. % | 4 = Proximity
  11. % scaleByDistanceFlag | 1 = yes
  12. % scaleByModSizeFlag | 1 = yes
  13. % scaleByPatchSizeFlag | 1 = yes
  14. % distance | distance from center of patch
  15. % maskFN | inclusive mask specifying what voxels in the
  16. % | brain to consider in the calculations
  17. %
  18. % Requirements
  19. %--------------------------------------------------------------------------
  20. % Tools for NIfTI and ANALYZE image - Jimmy Shen
  21. % Available here: https://www.mathworks.com/matlabcentral/fileexchange/8797-tools-for-nifti-and-analyze-image
  22. %
  23. % Release
  24. %--------------------------------------------------------------------------
  25. % 10/22/25 - Robert Lyday
  26. %
  27. %
  28. % % Warning: This code is provided "as is"
  29. % Use at your own risk
  34. img1 = load_untouch_nii(niiFN);
  36. atlas = load_untouch_nii(maskFN);
  37. pointer = find(atlas.img(:));
  39. % convert pointer to x,y,z
  40. [xindex, yindex, zindex] = ind2sub(size(atlas.img),pointer);
  42. maxDist = distance;
  43. maxMod = max(img1.img(:));
  44. for m = 1:maxMod
  45. modSize(m) = sum(img1.img==m,'all');
  46. end
  47. modSize = 1 - (modSize ./ sum(modSize));
  48. modSize_inv = 1 - modSize;
  50. if sum(size(img1.img)-size(atlas.img))
  51. fprintf('size nii %d\t%d\t%d\n',size(img1.img));
  52. fprintf('size atlas %d\t%d\t%d\n',size(atlas.img));
  53. error('module image and voxel mask do not match!')
  54. end
  56. imgOut = img1;
  57. imgOut.img = imgOut.img * 0;
  59. switch entropyMethod
  60. case 1
  61. %------------------------------------------------------------------
  62. % ----- Shannon -----
  63. %------------------------------------------------------------------
  64. neighborCounts = zeros(size(xindex));
  65. for index = 1:length(xindex)
  67. x = xindex(index);
  68. y = yindex(index);
  69. z = zindex(index);
  71. modProb = zeros(max(maxMod),1);
  72. count = 0;
  73. for xx = -maxDist:1:maxDist
  74. for yy = -maxDist:1:maxDist
  75. for zz = -maxDist:1:maxDist
  76. try
  77. currMod = img1.img(x+xx,y+yy,z+zz);
  78. maskCheck = atlas.img(x+xx,y+yy,z+zz);
  79. currDist = sqrt((xx^2)+(yy^2)+(zz^2));
  80. if currDist == 0
  81. currDist = 1;
  82. end
  83. if maskCheck && currDist<=maxDist
  84. count = count + 1;
  85. if currMod
  86. val = 1;
  87. if scaleByDistanceFlag
  88. val = val ./ currDist;
  89. end
  90. modProb(currMod) = modProb(currMod) + val;
  91. end
  92. end
  93. end
  94. end
  95. end
  96. end
  97. neighborCounts(index) = count;
  98. % scale modProb
  99. origModProb = modProb;
  100. modProb = modProb ./ sum(modProb);
  101. % calc entropy
  102. entVal = 0;
  103. for m = 1:maxMod
  104. if scaleByPatchSize == 1
  105. lambda = modProb(m) / count;
  106. else
  107. lambda = modProb(m);
  108. end
  109. if scaleByModSizeFlag==1
  110. temp = modSize(m) .* modProb(m) * log(1/(lambda));
  111. if isnan(temp) || isinf(temp)
  112. temp = 0;
  113. end
  114. entVal = entVal + temp;
  115. elseif scaleByModSizeFlag==2
  116. temp = modSize_inv(m) .* modProb(m) * log(1/(lambda));
  117. if isnan(temp) || isinf(temp)
  118. temp = 0;
  119. end
  120. entVal = entVal + temp;
  121. else
  122. if scaleByPatchSize == 2
  123. temp = modProb(m) * log(1/lambda) / count; %bring patch size scaling outside of log function -CM 7.3.25
  124. if isnan(temp) || isinf(temp)
  125. temp = 0;
  126. end
  127. entVal = entVal + temp;
  128. else
  129. temp = modProb(m) * log(1/lambda);
  130. if isnan(temp) || isinf(temp)
  131. temp = 0;
  132. end
  133. entVal = entVal + temp;
  134. end
  135. end
  136. end
  137. if entVal == 0
  138. entVal;
  139. end
  140. imgOut.img(x,y,z) = entVal;
  141. end
  146. case 2
  147. %------------------------------------------------------------------
  148. % ----- O'Neill -----
  149. %------------------------------------------------------------------
  150. for index = 1:length(xindex)
  151. x = xindex(index);
  152. y = yindex(index);
  153. z = zindex(index);
  154. modProb = zeros(max(maxMod),max(maxMod));
  155. count = 0;
  156. patchLocs = [];
  157. patchLocsDists = [];
  158. for xx = -maxDist:1:maxDist
  159. for yy = -maxDist:1:maxDist
  160. for zz = -maxDist:1:maxDist
  161. try
  162. maskCheck = atlas.img(x+xx,y+yy,z+zz);
  163. currDist = sqrt((xx^2)+(yy^2)+(zz^2));
  164. if maskCheck && currDist<=maxDist
  165. patchLocs(end+1,:) = [x+xx,y+yy,z+zz];
  166. patchLocsDists(end+1) = currDist;
  167. end
  168. end
  169. end
  170. end
  171. end
  172. for patchIndexi = 1:size(patchLocs,1)
  173. for patchIndexj = 1:size(patchLocs,1)
  174. currDist = sqrt(((patchLocs(patchIndexj,1)-patchLocs(patchIndexi,1))^2)+((patchLocs(patchIndexj,2)-patchLocs(patchIndexi,2))^2)+((patchLocs(patchIndexj,3)-patchLocs(patchIndexi,3))^2));
  175. if currDist == 1
  176. modi = img1.img(patchLocs(patchIndexi,1),patchLocs(patchIndexi,2),patchLocs(patchIndexi,3));
  177. modj = img1.img(patchLocs(patchIndexj,1),patchLocs(patchIndexj,2),patchLocs(patchIndexj,3));
  178. if modi && modj
  179. count = count + 1;
  180. distVal = 1;
  181. if scaleByDistanceFlag
  182. distVal = (patchLocsDists(patchIndexi)+patchLocsDists(patchIndexj))/2;
  183. end
  184. modProb(modi,modj) = modProb(modi,modj) + 1 / distVal;
  185. modProb(modj,modi) = modProb(modi,modj);
  186. end
  187. end
  188. end
  189. end
  191. % scale modProb
  192. modProbOrig = modProb;
  193. modProb = modProb ./ sum(modProb(:));
  194. % calc entropy
  195. entVal = 0;
  196. % vals = [];
  197. for m = 1:maxMod
  198. for mm = 1:maxMod
  199. if scaleByPatchSize == 1
  200. lambda = modProb(m,mm) / count;
  201. else
  202. lambda = modProb(m,mm);
  203. end
  204. if scaleByModSizeFlag == 1
  205. temp = modSize(m) .* modProb(m,mm) * log(1/(lambda));
  206. if isnan(temp) || isinf(temp)
  207. temp = 0;
  208. end
  209. entVal = entVal + temp;
  210. elseif scaleByModSizeFlag == 2
  211. temp = modSize_inv(m) .* modProb(m,mm) * log(1/(lambda));
  212. if isnan(temp) || isinf(temp)
  213. temp = 0;
  214. end
  215. entVal = entVal + temp;
  216. else
  217. if scaleByPatchSize == 2 %patch size scaler outside of log -CM 7.3
  218. temp = modProb(m,mm) * log(1/lambda) / count;
  219. if isnan(temp) || isinf(temp)
  220. temp = 0;
  221. end
  222. entVal = entVal + temp;
  223. else
  224. temp = modProb(m,mm) * log(1/lambda);
  225. if isnan(temp) || isinf(temp)
  226. temp = 0;
  227. end
  228. entVal = entVal + temp;
  229. % vals(end+1) = temp;
  230. end
  231. end
  232. end
  233. end
  235. imgOut.img(x,y,z) = entVal;
  236. end
  239. case 3
  240. %------------------------------------------------------------------
  241. % ----- Clarmunt -----
  242. %------------------------------------------------------------------
  243. for index = 1:length(xindex)
  244. x = xindex(index);
  245. y = yindex(index);
  246. z = zindex(index);
  247. modProb = zeros(max(maxMod),1);
  248. count = 0;
  249. patchLocs = [];
  250. for xx = -maxDist:1:maxDist
  251. for yy = -maxDist:1:maxDist
  252. for zz = -maxDist:1:maxDist
  253. try
  254. maskCheck = atlas.img(x+xx,y+yy,z+zz);
  255. currDist = sqrt((xx^2)+(yy^2)+(zz^2));
  256. if maskCheck && currDist<=maxDist
  257. patchLocs(end+1,:) = [x+xx,y+yy,z+zz];
  258. end
  259. end
  260. end
  261. end
  262. end
  263. count = size(patchLocs,1);
  264. modVals = [];
  265. modDists = [];
  266. for patchIndexi = 1:size(patchLocs,1)
  267. modVals(patchIndexi) = img1.img(patchLocs(patchIndexi,1),patchLocs(patchIndexi,2),patchLocs(patchIndexi,3));
  268. for patchIndexj = 1:size(patchLocs,1)
  269. currDist = sqrt(((patchLocs(patchIndexj,1)-patchLocs(patchIndexi,1))^2)+((patchLocs(patchIndexj,2)-patchLocs(patchIndexi,2))^2)+((patchLocs(patchIndexj,3)-patchLocs(patchIndexi,3))^2));
  270. modDists(patchIndexi, patchIndexj) = currDist;
  271. end
  272. end
  273. % set diagonal = nan
  274. modDists(1:length(modDists)+1:end)=nan;
  276. % calc modProb
  277. for m = 1:maxMod
  278. modProb(m) = sum(modVals == m) / sum(modVals > 0);
  279. end
  280. % calc entropy
  281. entVal = 0;
  282. for m = 1:maxMod
  283. if scaleByPatchSize == 1
  284. lambda = modProb(m) / count;
  285. else
  286. lambda = modProb(m);
  287. end
  288. locs1 = modVals == m;
  289. locs2 = (modVals~=m) & (modVals > 0);
  290. temp = modDists(locs1,locs1);
  291. tempDist1 = mean(temp(:),'omitnan');
  292. if tempDist1 == 0
  293. tempDist1 = 1;
  294. end
  295. temp = modDists(locs1,locs2);
  296. tempDist2 = mean(temp(:),'omitnan');
  297. if tempDist2 == 0
  298. tempDist2 = 1;
  299. end
  300. tempDist = tempDist1/tempDist2;
  302. %%% Added second scale by module size (020) CM 7.2.25
  303. if scaleByModSizeFlag == 1
  304. temp = tempDist .* modSize(m) .* modProb(m) * log(1/(lambda));
  305. if isnan(temp) || isinf(temp)
  306. temp = 0;
  307. end
  308. entVal = entVal + temp;
  309. elseif scaleByModSizeFlag == 2
  310. temp = tempDist .* modSize_inv(m) .* modProb(m) * log(1/(lambda));
  311. if isnan(temp) || isinf(temp)
  312. temp = 0;
  313. end
  314. entVal = entVal + temp;
  317. else
  318. if scaleByPatchSize == 2
  319. temp = tempDist * modProb(m) * log(1/lambda) / count;
  320. if isnan(temp) || isinf(temp)
  321. temp = 0;
  322. end
  323. entVal = entVal + temp;
  324. else
  325. temp = tempDist * modProb(m) * log(1/lambda);
  326. if isnan(temp) || isinf(temp)
  327. temp = 0;
  328. end
  329. entVal = entVal + temp;
  330. end
  331. end
  332. end
  333. imgOut.img(x,y,z) = entVal;
  334. end
  337. case 4
  338. %------------------------------------------------------------------
  339. % ----- Proximity -----
  340. %------------------------------------------------------------------
  341. for index = 1:length(xindex)
  342. % if index==82
  343. % index
  344. % end
  345. x = xindex(index);
  346. y = yindex(index);
  347. z = zindex(index);
  348. modProb = zeros(max(maxMod),1);
  349. modEdgeCount = zeros(max(maxMod),max(maxMod));
  350. count = 0;
  351. patchLocs = [];
  352. patchLocsDists = [];
  353. modVals = [];
  354. for xx = -maxDist:1:maxDist
  355. for yy = -maxDist:1:maxDist
  356. for zz = -maxDist:1:maxDist
  357. try
  358. maskCheck = atlas.img(x+xx,y+yy,z+zz);
  359. currDist = sqrt((xx^2)+(yy^2)+(zz^2));
  360. if maskCheck && currDist<=maxDist
  361. patchLocs(end+1,:) = [x+xx,y+yy,z+zz];
  362. patchLocsDists(end+1) = currDist;
  363. end
  364. end
  365. end
  366. end
  367. end
  368. for patchIndexi = 1:size(patchLocs,1)
  369. modVals(patchIndexi) = img1.img(patchLocs(patchIndexi,1),patchLocs(patchIndexi,2),patchLocs(patchIndexi,3));
  370. for patchIndexj = 1:size(patchLocs,1)
  371. currDist = sqrt(((patchLocs(patchIndexj,1)-patchLocs(patchIndexi,1))^2)+((patchLocs(patchIndexj,2)-patchLocs(patchIndexi,2))^2)+((patchLocs(patchIndexj,3)-patchLocs(patchIndexi,3))^2));
  372. if currDist == 1
  373. modi = img1.img(patchLocs(patchIndexi,1),patchLocs(patchIndexi,2),patchLocs(patchIndexi,3));
  374. modj = img1.img(patchLocs(patchIndexj,1),patchLocs(patchIndexj,2),patchLocs(patchIndexj,3));
  375. if modi && modj
  376. count = count + 1;
  377. modEdgeCount(modi,modj) = modEdgeCount(modi,modj) + 1;
  378. modEdgeCount(modj,modi) = modEdgeCount(modi,modj);
  379. end
  380. end
  381. end
  382. end
  384. % zero self modProb
  385. modEdgeCount(1:maxMod+1:end) = 0;
  386. for m = 1:maxMod
  387. modProb(m) = sum(modVals==m) ./ sum(modVals>0);
  388. end
  390. % calc dist matrix
  391. centroids = [];
  392. for m = 1:maxMod
  393. centroids(m,:)=mean(patchLocs(modVals==m,:),1);
  394. end
  395. for m = 1:maxMod
  396. for mm = 1:maxMod
  397. distMat(m,mm) = sqrt((centroids(m,1)-centroids(mm,1))^2 + (centroids(m,2)-centroids(mm,2))^2 + (centroids(m,3)-centroids(mm,3))^2);
  398. end
  399. end
  400. distMat(1:maxMod+1:end) = nan;
  402. % calc entropy
  403. entVal = 0;
  404. for m = 1:maxMod
  405. if scaleByPatchSize == 1
  406. lambda = modProb(m) / count;
  407. else
  408. lambda = modProb(m);
  409. end
  410. li = sum(modEdgeCount(m,:));
  411. di = mean(distMat(m,:),'omitnan');
  412. if di < 1
  413. di = 1;
  414. end
  416. if scaleByModSizeFlag == 1
  417. temp = li/di * modSize(m) .* modProb(m) * log(1/(lambda));
  418. if isnan(temp) || isinf(temp)
  419. temp = 0;
  420. end
  421. entVal = entVal + temp;
  422. elseif scaleByModSizeFlag == 2
  423. temp = li/di * modSize_inv(m) .* modProb(m) * log(1/(lambda));
  424. if isnan(temp) || isinf(temp)
  425. temp = 0;
  426. end
  427. entVal = entVal + temp;
  430. else
  431. if scaleByPatchSize == 2
  432. temp = li/di * modProb(m) * log(1/lambda) / count;
  433. if isnan(temp) || isinf(temp)
  434. temp = 0;
  435. end
  436. entVal = entVal + temp;
  437. else
  439. temp = li/di * modProb(m) * log(1/lambda);
  440. if isnan(temp) || isinf(temp)
  441. temp = 0;
  442. end
  443. entVal = entVal + temp;
  444. end
  445. end
  446. end
  447. imgOut.img(x,y,z) = entVal;
  448. end
  450. otherwise
  451. error('Entropy method should be a number from 1 to 4');
  452. end
  454. pth = fileparts(outFN);
  455. if ~exist(pth,'dir')
  456. mkdir(pth);
  457. end
  458. save_untouch_nii(imgOut,outFN);

entropyCalc.m at commit 0256f55, no license · at the source

Overview

Authors: Clayton C. McIntyre1, Shannon M. O’Donnell1, Mohammadreza Khodaei2, Robert G. Lyday3, Jonathan H. Burdette3, Paul J. Laurienti3
ORCID iDs: Clayton C. McIntyre, Shannon M. O’Donnell
  1. Wake Forest Graduate School of Arts and Sciences Neuroscience Graduate Program Winston‐Salem North Carolina USA
  2. School of Biomedical Engineering and Sciences Virginia Tech‐Wake Forest University Winston‐Salem North Carolina USA
  3. Department of Radiology Wake Forest University School of Medicine Winston‐Salem North Carolina USA
Institutions: Wake Forest University (United States); Virginia Tech - Wake Forest University School of Biomedical Engineering & Sciences (United States); Virginia Tech (United States); Wake Forest University Health Sciences (United States)
Journal: Human brain mapping, volume 47, issue 5, article e70525
Dates: received 4 November 2025; accepted 29 March 2026; published online 7 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1002/hbm.70525 · PMID 41947544 · PMCID PMC13058231 · OpenAlex W4415529349
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.10.23.684130
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Graphs, fMRI & imaging
Keywords: brain networks, entropy, music, self‐organization, working memory
MeSH: Auditory Perception*, Brain*, Brain Mapping*, Connectome*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Memory, Short-Term*, Nerve Net*, Entropy, Humans, Music (* major topic)
Topic: Functional Brain Connectivity Studies (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: National Institute on Alcohol Abuse and Alcoholism (P50AA026117, R01AA029926, F31AA032409)
Citations: cited by 1 paper (Europe PMC); 46 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above.

rlyday/brain-network-spatial-entropy

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 0256f55b7eb92a46f68b046ce8181bd154712510, 22 October 2025
Languages: MATLAB (1)
Size: 1 file, 1 script
Software Heritage: not archived
Found in: “Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Tools for NIfTI and ANALYZE image (MATLAB) (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
1 file
At the source: github.com/rlyday/brain-network-spatial-entropy

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1002/hbm.70525.

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;
  • 1 script, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • it says that the data are available on request

Read it in the paper: doi.org/10.1002/hbm.70525.

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, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 5 keywords, 11 MeSH terms, 1 funder, 44 references.

Cite

This paper

McIntyre, C. C., O’Donnell, S. M., Khodaei, M., Lyday, R. G., Burdette, J. H., & Laurienti, P. J. (2026). Spatial Entropy of Brain Network Landscapes: A Novel Method to Assess Spatial Disorder in Brain Networks. Human brain mapping, 47(5), e70525. https://doi.org/10.1002/hbm.70525

BibTeX

@article{mcintyre2026spatial,
author = {McIntyre, Clayton C. and O’Donnell, Shannon M. and Khodaei, Mohammadreza and Lyday, Robert G. and Burdette, Jonathan H. and Laurienti, Paul J.},
title = {{Spatial Entropy of Brain Network Landscapes: A Novel Method to Assess Spatial Disorder in Brain Networks}},
journal = {Human brain mapping},
year = {2026},
month = apr,
volume = {47},
number = {5},
pages = {e70525},
publisher = {Wiley},
issn = {1065-9471},
doi = {10.1002/hbm.70525},
url = {https://doi.org/10.1002/hbm.70525},
pmid = {41947544},
pmcid = {PMC13058231}
}

RIS

TY - JOUR
AU - McIntyre, Clayton C.
AU - O’Donnell, Shannon M.
AU - Khodaei, Mohammadreza
AU - Lyday, Robert G.
AU - Burdette, Jonathan H.
AU - Laurienti, Paul J.
TI - Spatial Entropy of Brain Network Landscapes: A Novel Method to Assess Spatial Disorder in Brain Networks
T2 - Human brain mapping
J2 - Hum Brain Mapp
PY - 2026
DA - 2026/04/01
VL - 47
IS - 5
SP - e70525
SN - 1065-9471
PB - Wiley
DO - 10.1002/hbm.70525
UR - https://doi.org/10.1002/hbm.70525
LA - en
ER -

CSL-JSON

{
"id": "10.1002/hbm.70525",
"type": "article-journal",
"title": "Spatial Entropy of Brain Network Landscapes: A Novel Method to Assess Spatial Disorder in Brain Networks",
"container-title": "Human brain mapping",
"author": [
{
"family": "McIntyre",
"given": "Clayton C."
},
{
"family": "O’Donnell",
"given": "Shannon M."
},
{
"family": "Khodaei",
"given": "Mohammadreza"
},
{
"family": "Lyday",
"given": "Robert G."
},
{
"family": "Burdette",
"given": "Jonathan H."
},
{
"family": "Laurienti",
"given": "Paul J."
}
],
"container-title-short": "Hum Brain Mapp",
"volume": "47",
"issue": "5",
"page": "e70525",
"DOI": "10.1002/hbm.70525",
"PMID": "41947544",
"PMCID": "PMC13058231",
"ISSN": "1065-9471",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/hbm.70525",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
1
]
]
}
}

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.1162/imag.a.1254 [code]
The individuality of single-frame functional brain connectivity.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: 5 references, author Clayton C. McIntyre
[2] doi:10.21203/rs.3.rs-9326213/v1 [code]
Multi-task fMRI outperforms resting-state fMRI for revealing task-invariant organization of the human brain
Journal: Research Square (preprint)
In common: cognitive, 5 references
[3] doi:10.1002/advs.202523009 [code]
Personalized Network-Guided Neuromodulation Enhances Human Working Memory.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: Tools for NIfTI and ANALYZE image (MATLAB), cognitive, 3 references
[4] doi:10.1162/imag.a.1222 [code]
Network-based near-scalp personalized brain stimulation targets.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Tools for NIfTI and ANALYZE image (MATLAB), 3 references
[5] doi:10.1016/j.neuron.2026.04.011 [code]
Precision fMRI reveals densely interdigitated network patches with conserved motifs in the lateral prefrontal cortex.
Journal: Neuron
In common: Tools for NIfTI and ANALYZE image (MATLAB), 3 references
[6] doi:10.7554/elife.108408 [code]
Frequency and laminar profile of feature-specific visual activity revealed by interleaved EEG-fMRI.
Journal: eLife
In common: Tools for NIfTI and ANALYZE image (MATLAB), 3 references
[7] doi:10.1038/s41467-026-75745-8 [code]
A language network in the individualized functional connectomes of 1199 human brains doing arbitrary tasks.
Journal: Nature communications
In common: cognitive, 4 references
[8] doi:10.1038/s41467-026-75959-w [code]
Charting higher-order models of brain function beyond pairwise interactions.
Journal: Nature communications
In common: 4 references
[9] doi:10.1162/imag.a.1262 [code]
Frame-wise multi-echo distortion correction for superior functional MRI.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Tools for NIfTI and ANALYZE image (MATLAB), 3 references
[10] doi:10.1038/s41598-026-49900-6 [code]
Global neural oscillations underlie performance variability and attentional state fluctuations in humans.
Journal: Scientific reports
In common: Tools for NIfTI and ANALYZE image (MATLAB), cognitive, 2 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.