OSCR

Brain-derived plasma p-tau217 shows enhanced dynamic range for Alzheimer's disease neuropathological change.

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] § METHODS › Tau‐PET imaging ↔ src/RSF.c, lines 395–464 · score 0.52 · FreeSurfer defined, ROIs, PET, fields

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

C · 793 lines · 26 KB · BSD-3-Clause · 1 match

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <stdbool.h>
  5. #include <math.h>
  6. #include <time.h>
  7. #include <endianio.h>
  8. #include <Getifh.h>
  9. #include <rec.h>
  10. #include <librms.h>
  11. #include <nrutil.h>
  12. #include <RSF.h>
  14. IMAGE_4dfp *read_image_4dfp(char *filespc, IMAGE_4dfp *image)
  15. {
  16. int n, m1, m2, isbig;
  17. char imgroot[MAXL], imgfile[MAXL];
  18. FILE *imgfp=NULL;
  20. if (!image) {
  21. image=(IMAGE_4dfp *)malloc((size_t)sizeof(IMAGE_4dfp));
  22. if (!image) errm("read_image_4dfp");
  23. getroot(filespc, imgroot);
  24. sprintf (imgfile, "%s.4dfp.img", imgroot);
  25. Getifh(imgfile, &(image->ifh));
  26. m2=image->ifh.number_of_bytes_per_pixel*image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  27. } else {
  28. m1=image->ifh.number_of_bytes_per_pixel*image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  29. getroot(filespc, imgroot);
  30. sprintf (imgfile, "%s.4dfp.img", imgroot);
  31. Getifh(imgfile, &(image->ifh));
  32. m2=image->ifh.number_of_bytes_per_pixel*image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  33. if (m1!=m2) { /*free old memory if the image size does not match*/
  34. free((void *) image->image);
  35. }
  36. }
  37. isbig = strcmp (image->ifh.imagedata_byte_order, "littleendian");
  38. if (!(imgfp = fopen (imgfile, "rb"))) errr ("read_image_4dfp", imgfile);
  39. m2=m2/image->ifh.number_of_bytes_per_pixel;
  40. image->image=(float *)malloc((size_t)(m2*sizeof(float))); /*Allocate memory for reading the image*/
  41. if (!image->image) errm("read_image_4dfp");
  42. if (eread(image->image, m2, isbig, imgfp)) errr("read_image_4dfp", imgfile);
  43. fclose(imgfp);
  44. return image;
  45. }
  47. int write_image_4dfp(char *filespc, IMAGE_4dfp *image)
  48. {
  49. int isbig, vdim, status = 0;
  50. char imgroot[MAXL], imgfile[MAXL], command[MAXL];
  51. FILE *imgfp;
  52. char control = '\0';
  54. isbig = strcmp (image->ifh.imagedata_byte_order, "littleendian");
  55. if (!control) control = (isbig) ? 'b' : 'l';
  56. vdim=image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  57. getroot(filespc, imgroot);
  58. sprintf(imgfile, "%s.4dfp.img", imgroot);
  59. if (!(imgfp = fopen (imgfile, "wb"))) errw("write_image_4dfp", imgfile);
  60. if (ewrite(image->image, vdim, control, imgfp)) errw("write_image_4dfp", imgfile);
  62. /* ifh hdr rec */
  63. if (fclose(imgfp)) errw("write_image_4dfp", imgfile);
  64. if (Writeifh("write_image_4dfp", imgfile, &image->ifh, control)) errw("write_image_4dfp", imgroot);
  65. sprintf(command, "ifh2hdr %s", imgroot);
  66. status |= system (command);
  67. return status;
  68. }
  70. float getroimean_4dfp(IMAGE_4dfp *in_image, IMAGE_4dfp *Mask, int val)
  71. {
  72. float *fptr1, *fptr2, roimean, lo, hi;
  73. int i, n, nv;
  75. /*need to implement a input checking mechanism*/
  77. roimean=0;
  78. n=0;
  79. fptr1 = in_image->image;
  80. fptr2 = Mask->image;
  81. lo=(float)val - 0.5;
  82. hi=(float)val + 0.5;
  83. nv = in_image->ifh.matrix_size[0]*in_image->ifh.matrix_size[1]*in_image->ifh.matrix_size[2]*in_image->ifh.matrix_size[3];
  84. for (i=0; i<nv; i++)
  85. {
  86. if (*fptr2<hi && *fptr2>lo) {
  87. n++;
  88. roimean+=*fptr1;
  89. }
  90. fptr1++;
  91. fptr2++;
  92. }
  93. if (n>0) {
  94. roimean=roimean/(float)n;
  95. } else {
  96. printf("Warning: ROI has no voxels\n");
  97. }
  98. return roimean;
  99. }
  102. IMAGE_4dfp *copy_image_4dfp(IMAGE_4dfp *in_image, IMAGE_4dfp *out_image)
  103. {
  104. int i, m1, m2;
  105. float *fptr1, *fptr2;
  107. m2=in_image->ifh.number_of_bytes_per_pixel*in_image->ifh.matrix_size[0]*in_image->ifh.matrix_size[1]*in_image->ifh.matrix_size[2]*in_image->ifh.matrix_size[3];
  108. if (!out_image) {
  109. out_image=(IMAGE_4dfp *)malloc((size_t)sizeof(IMAGE_4dfp));
  110. if (!out_image) errm("copy_image_4dfp");
  111. out_image->image=(float *)malloc((size_t)m2);
  112. if (!out_image->image) errm("copy_image_4dfp");
  113. } else {
  114. m1=out_image->ifh.number_of_bytes_per_pixel*out_image->ifh.matrix_size[0]*out_image->ifh.matrix_size[1]*out_image->ifh.matrix_size[2]*out_image->ifh.matrix_size[3];
  115. if (m1!=m2) {
  116. free((void *) out_image->image);
  117. out_image->image=(float *)malloc((size_t)m2);
  118. if (!out_image->image) errm("copy_image_4dfp");
  119. }
  121. }
  122. strcpy(out_image->ifh.interfile, in_image->ifh.interfile);
  123. strcpy(out_image->ifh.version_of_keys, in_image->ifh.version_of_keys);
  124. strcpy(out_image->ifh.conversion_program, in_image->ifh.conversion_program);
  125. strcpy(out_image->ifh.name_of_data_file, in_image->ifh.name_of_data_file);
  126. /* needs to modify out_image->name_of_data_file to avoid duplication of file names*/
  127. strcpy(out_image->ifh.number_format, in_image->ifh.number_format);
  128. strcpy(out_image->ifh.imagedata_byte_order, in_image->ifh.imagedata_byte_order);
  129. out_image->ifh.number_of_bytes_per_pixel=in_image->ifh.number_of_bytes_per_pixel;
  130. out_image->ifh.number_of_dimensions=in_image->ifh.number_of_dimensions;
  131. for (i=0; i<3; i++)
  132. {
  133. out_image->ifh.matrix_size[i]=in_image->ifh.matrix_size[i];
  134. out_image->ifh.scaling_factor[i]=in_image->ifh.scaling_factor[i];
  135. out_image->ifh.mmppix[i]=in_image->ifh.mmppix[i];
  136. out_image->ifh.center[i]=in_image->ifh.center[i];
  137. }
  138. out_image->ifh.matrix_size[3]=in_image->ifh.matrix_size[3];
  139. out_image->ifh.scaling_factor[3]=in_image->ifh.scaling_factor[3];
  140. out_image->ifh.orientation=in_image->ifh.orientation;
  141. m2=m2/in_image->ifh.number_of_bytes_per_pixel;
  142. fptr1=in_image->image;
  143. fptr2=out_image->image;
  144. for (i=0; i<m2; i++)
  145. {
  146. *fptr2=*fptr1;
  147. fptr1++;
  148. fptr2++;
  149. }
  150. return out_image;
  151. }
  153. IMAGE_4dfp *extract_roi_4dfp(IMAGE_4dfp *image, int MaskVal, IMAGE_4dfp *roimask)
  154. {
  155. int i, m1, m2;
  156. float *fptr1, *fptr2, lo, hi;
  158. m2=image->ifh.number_of_bytes_per_pixel*image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  159. if (!roimask) {
  160. roimask=(IMAGE_4dfp *)malloc((size_t)sizeof(IMAGE_4dfp));
  161. if (!roimask) errm("extract_roi_4dfp");
  162. roimask->image=(float *)malloc((size_t)m2);
  163. if (!roimask->image) errm("extract_roi_4dfp");
  164. } else {
  165. m1=roimask->ifh.number_of_bytes_per_pixel*roimask->ifh.matrix_size[0]*roimask->ifh.matrix_size[1]*roimask->ifh.matrix_size[2]*roimask->ifh.matrix_size[3];
  166. if (m1!=m2) {
  167. free((void *) roimask->image);
  168. roimask->image=(float *)malloc((size_t)m2);
  169. if (!roimask->image) errm("extract_roi_4dfp");
  170. }
  172. }
  173. strcpy(roimask->ifh.interfile, image->ifh.interfile);
  174. strcpy(roimask->ifh.version_of_keys, image->ifh.version_of_keys);
  175. strcpy(roimask->ifh.conversion_program, image->ifh.conversion_program);
  176. strcpy(roimask->ifh.name_of_data_file, image->ifh.name_of_data_file);
  177. /* needs to modify roimask->name_of_data_file to avoid duplication of file names*/
  178. strcpy(roimask->ifh.number_format, image->ifh.number_format);
  179. strcpy(roimask->ifh.imagedata_byte_order, image->ifh.imagedata_byte_order);
  180. roimask->ifh.number_of_bytes_per_pixel=image->ifh.number_of_bytes_per_pixel;
  181. roimask->ifh.number_of_dimensions=image->ifh.number_of_dimensions;
  182. for (i=0; i<3; i++)
  183. {
  184. roimask->ifh.matrix_size[i]=image->ifh.matrix_size[i];
  185. roimask->ifh.scaling_factor[i]=image->ifh.scaling_factor[i];
  186. roimask->ifh.mmppix[i]=image->ifh.mmppix[i];
  187. roimask->ifh.center[i]=image->ifh.center[i];
  188. }
  189. roimask->ifh.matrix_size[3]=image->ifh.matrix_size[3];
  190. roimask->ifh.scaling_factor[3]=image->ifh.scaling_factor[3];
  191. roimask->ifh.orientation=image->ifh.orientation;
  192. fptr1=image->image;
  193. fptr2=roimask->image;
  194. m2=m2/image->ifh.number_of_bytes_per_pixel;
  195. lo = (float)MaskVal - 0.5;
  196. hi = (float)MaskVal + 0.5;
  197. for (i=0; i<m2; i++)
  198. {
  199. if (*fptr1<hi && *fptr1>lo) {
  200. *fptr2=1;
  201. } else {
  202. *fptr2=0;
  203. }
  204. fptr1++;
  205. fptr2++;
  206. }
  207. return roimask;
  208. }
  210. void getroismean_4dfp(IMAGE_4dfp *in_image, IMAGE_4dfp *Mask, int n, float *a)
  211. {
  212. float *fptr1, *fptr2, *p;
  213. int i, nv, idx;
  215. p=vector(1,n);
  216. for (i=1; i<=n; i++) {a[i]=0.0; p[i]=0.;}
  217. nv = in_image->ifh.matrix_size[0]*in_image->ifh.matrix_size[1]*in_image->ifh.matrix_size[2]*in_image->ifh.matrix_size[3];
  218. fptr1=in_image->image;
  219. fptr2=Mask->image;
  220. for (i=0; i<nv; i++) {
  221. idx=(int)rint((double)(*fptr2))+1;
  222. a[idx]+=*fptr1;
  223. p[idx]+=1.;
  224. if (idx>n) printf("something is wrong.\n");
  225. fptr1++;
  226. fptr2++;
  227. }
  228. for (i=1; i<=n; i++) {a[i]=a[i]/p[i];}
  229. }
  231. void getroismean2_4dfp(IMAGE_4dfp *in_image, IMAGE_4dfp *Mask, IMAGE_4dfp *PETMask, int n, float *a, float *p)
  232. {
  233. float *fptr1, *fptr2, *fptr3, m;
  234. int i, nv, idx, nm;
  237. for (i=1; i<=n; i++) {a[i]=0.0; p[i]=0.;}
  238. nv = in_image->ifh.matrix_size[0]*in_image->ifh.matrix_size[1]*in_image->ifh.matrix_size[2]*in_image->ifh.matrix_size[3];
  239. fptr1=in_image->image;
  240. fptr2=Mask->image;
  241. fptr3=PETMask->image;
  242. nm=0;
  243. m=0;
  244. for (i=0; i<nv; i++) {
  245. if (*fptr3>0){
  246. idx=(int)rint((double)(*fptr2))+1; /*belong to ROI # idx*/
  247. a[idx]+=*fptr1; /*sum for ROI #idx + voxel value*/
  248. p[idx]+=1.; /* voxel number for ROI #idx increase by 1 */
  249. if (idx>n) printf("something is wrong.\n");
  250. if (*fptr2 >0 ){
  251. nm++;
  252. m+=*fptr1;
  253. }
  254. }
  255. fptr1++;
  256. fptr2++;
  257. fptr3++;
  258. }
  259. m=m/(float)nm*.8;
  260. for (i=1; i<=n; i++) {
  261. if (p[i]>0) {
  262. a[i]=a[i]/p[i];
  263. /*printf("%f\t%f\n",p[i], a[i]);*/
  264. } else { /* to protect cases that ROI #i is completely out of PET field of view */
  265. a[i]=m; /* in such case, the ROI mean is replaced with mean value of all non-unknown regions multiplied by 0.8 */
  266. }
  267. }
  268. }
  270. void getroismean3_4dfp(IMAGE_4dfp *in_image, IMAGE_4dfp *Mask, IMAGE_4dfp *PETMask, int n, float *a, float *p)
  271. {
  272. /* get roimean excluding non-valid voxels */
  273. float *fptr1, *fptr2, *fptr3, m;
  274. int i, nv, idx, nm;
  277. for (i=1; i<=n; i++) {a[i]=0.0; p[i]=0.;}
  278. nv = in_image->ifh.matrix_size[0]*in_image->ifh.matrix_size[1]*in_image->ifh.matrix_size[2]*in_image->ifh.matrix_size[3];
  279. fptr1=in_image->image;
  280. fptr2=Mask->image;
  281. fptr3=PETMask->image;
  282. nm=0;
  283. m=0;
  284. for (i=0; i<nv; i++) {
  285. if (*fptr3>0 && isnormal (*fptr1) && *fptr1 != (float) 1.e-37 && *fptr1 !=0){
  286. idx=(int)rint((double)(*fptr2))+1; /*belong to ROI # idx*/
  287. a[idx]+=*fptr1; /*sum for ROI #idx + voxel value*/
  288. p[idx]+=1.; /* voxel number for ROI #idx increase by 1 */
  289. if (idx>n) printf("something is wrong.\n");
  290. if (*fptr2 >0 ){
  291. nm++;
  292. m+=*fptr1;
  293. }
  294. }
  295. fptr1++;
  296. fptr2++;
  297. fptr3++;
  298. }
  299. m=m/(float)nm*.8;
  300. for (i=1; i<=n; i++) {
  301. if (p[i]>0) {
  302. a[i]=a[i]/p[i];
  303. /*printf("%f\t%f\n",p[i], a[i]);*/
  304. } else { /* to protect cases that ROI #i is completely out of PET field of view */
  305. a[i]=0; /* in such case, the ROI mean is replaced with mean value of all non-unknown regions multiplied by 0.8 */
  306. }
  307. }
  308. }
  311. RSFMat *calrsfmat(IMAGE_4dfp *image, ROIList *rois, float fhalf)
  312. {
  313. RSFMat *rsfmat = NULL;
  314. IMAGE_4dfp *tmp_img=NULL;
  315. int val, nx, ny, nz, i, j, nv;
  316. float cmppix[3], *fptr, l;
  317. IFH tmp_ifh;
  318. clock_t start, end;
  321. rsfmat = (RSFMat *) malloc((size_t)sizeof(RSFMat));
  322. if (!rsfmat) errm("calrsfmat");
  323. rsfmat->n = rois->NumberOfRegions;
  324. rsfmat->mat = matrix(1,rsfmat->n,1,rsfmat->n);
  325. nx = image->ifh.matrix_size[0];
  326. ny = image->ifh.matrix_size[1];
  327. nz = image->ifh.matrix_size[2];
  328. cmppix[0]=image->ifh.scaling_factor[0]/10.;
  329. cmppix[1]=image->ifh.scaling_factor[1]/10.;
  330. cmppix[2]=image->ifh.scaling_factor[2]/10.;
  332. /* Converting roi values to consecutive numbers*/
  333. start = clock();
  334. nv = image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
  336. for (j=0; j<rois->NumberOfRegions; j++) {
  337. val = rois->List[j].MaskVal;
  338. fptr = image->image;
  339. for (i=0; i<nv; i++) {
  340. if (fabs(*fptr-(float)val)<1e-4) {
  341. *fptr=(float)j;
  342. }
  343. fptr++;
  344. }
  345. }
  346. fptr=image->image;
  347. l=(float)(rois->NumberOfRegions-.5);
  348. for (i=0; i<nv; i++) {
  349. if (*fptr>l) *fptr=0;
  350. fptr++;
  351. }
  353. end = clock();
  354. printf("CPU TIME USED for roi preprocessing is %f\n",((double) (end - start)) / CLOCKS_PER_SEC);
  356. /* Calculate RSF Matrix */
  357. for (i=1;i<=rsfmat->n;i++) {
  358. printf("%s\n", rois->List[i-1].Name);
  359. tmp_img=extract_roi_4dfp(image, i-1, tmp_img);
  360. start = clock();
  361. gauss3d(tmp_img->image, &nx, &ny, &nz, cmppix, &fhalf);
  362. end = clock();
  363. printf("CPU TIME USED for gauss3d is %f\n",((double) (end - start)) / CLOCKS_PER_SEC);
  364. start = clock();
  365. getroismean_4dfp(tmp_img, image, rsfmat->n, rsfmat->mat[i]);
  366. /*for (j=1; j<=rsfmat->n; j++) {
  367. printf("%e\n",rsfmat->mat[i][j]);
  368. }*/
  369. end = clock();
  370. printf("CPU TIME USED for getroimeans is %f\n",((double) (end - start)) / CLOCKS_PER_SEC);
  371. }
  374. /*
  375. for (i=1;i<=rsfmat->n;i++) {
  376. printf("%s\n", rois->List[i-1].Name);
  377. val = rois->List[i-1].MaskVal;
  378. tmp_img=extract_roi_4dfp(image, val, tmp_img);
  379. start = clock();
  380. gauss3d(tmp_img->image, &nx, &ny, &nz, cmppix, &fhalf);
  381. end = clock();
  382. printf("CPU TIME USED for gauss3d is %f\n",((double) (end - start)) / CLOCKS_PER_SEC);
  383. start = clock();
  384. for (j=1; j<=rsfmat->n; j++) {
  385. rsfmat->mat[i][j]=getroimean_4dfp(tmp_img, image, rois->List[j-1].MaskVal);
  386. printf("%e\n",rsfmat->mat[i][j]);
  387. }
  388. end = clock();
  389. printf("CPU TIME USED for getroimean is %f\n",((double) (end - start)) / CLOCKS_PER_SEC);
  390. }
  391. */
  392. return rsfmat;
  393. }
  395. RSFROIS *Preprocess_RSF(IMAGE_4dfp *FS_Mask, IMAGE_4dfp *Head_Mask, IMAGE_4dfp *PET_Mask, RSFROIS *rsfrois, char *FSLUT)
  396. /*
  397. Combine Freesurfer defined masks, MR based head mask, and PET field of view based mask into a RSF Mask. It makes
  398. sure that meaningful ROIs are only defined on those area within PET field of view.
  399. */
  400. {
  401. int i, j, k, nv, tmp, xb, yb, zb, x, y, z, FSVal[16384], nfsroi, nroi, fsflag[16384], oflag[64], fsidx, val, maxfsval;
  402. float *fptr1, *fptr2, *fptr3, *fptr4, l;
  403. char **FSRegions = NULL;
  404. char line[512], otherstr[256];
  405. FILE *fp = NULL;
  407. printf("0\n");
  409. /* allocate memory and initiate rsfrois */
  410. nv=FS_Mask->ifh.number_of_bytes_per_pixel*FS_Mask->ifh.matrix_size[0]*FS_Mask->ifh.matrix_size[1]*FS_Mask->ifh.matrix_size[2]*FS_Mask->ifh.matrix_size[3];
  411. if (!rsfrois) {
  412. rsfrois=(RSFROIS *)malloc((size_t)sizeof(RSFROIS));
  413. if (!rsfrois) errm("Preprocess_RSF");
  414. rsfrois->RSFMask=(IMAGE_4dfp *)malloc((size_t)sizeof(IMAGE_4dfp));
  415. if (!rsfrois->RSFMask) errm("Preprocess_RSF");
  416. rsfrois->RSFMask->image=(float *)malloc((size_t)nv);
  417. if (!rsfrois->RSFMask->image) errm("Preprocess_RSF");
  418. rsfrois->rois=(ROIList *)malloc((size_t)sizeof(ROIList));
  419. if (!rsfrois->rois) errm("Preprocess_RSF");
  420. } else {
  421. nrerror("rsfrois should be a NULL pointer passing to Preprocess_RSF");
  422. }
  423. nv = nv/FS_Mask->ifh.number_of_bytes_per_pixel;
  424. strcpy(rsfrois->RSFMask->ifh.interfile, FS_Mask->ifh.interfile);
  425. strcpy(rsfrois->RSFMask->ifh.version_of_keys, FS_Mask->ifh.version_of_keys);
  426. strcpy(rsfrois->RSFMask->ifh.conversion_program, FS_Mask->ifh.conversion_program);
  427. strcpy(rsfrois->RSFMask->ifh.name_of_data_file, "RSFMask");
  429. strcpy(rsfrois->RSFMask->ifh.number_format, FS_Mask->ifh.number_format);
  430. strcpy(rsfrois->RSFMask->ifh.imagedata_byte_order, FS_Mask->ifh.imagedata_byte_order);
  431. rsfrois->RSFMask->ifh.number_of_bytes_per_pixel=FS_Mask->ifh.number_of_bytes_per_pixel;
  432. rsfrois->RSFMask->ifh.number_of_dimensions=FS_Mask->ifh.number_of_dimensions;
  433. for (i=0; i<3; i++)
  434. {
  435. rsfrois->RSFMask->ifh.matrix_size[i]=FS_Mask->ifh.matrix_size[i];
  436. rsfrois->RSFMask->ifh.scaling_factor[i]=FS_Mask->ifh.scaling_factor[i];
  437. rsfrois->RSFMask->ifh.mmppix[i]=FS_Mask->ifh.mmppix[i];
  438. rsfrois->RSFMask->ifh.center[i]=FS_Mask->ifh.center[i];
  439. }
  440. rsfrois->RSFMask->ifh.matrix_size[3]=FS_Mask->ifh.matrix_size[3];
  441. rsfrois->RSFMask->ifh.scaling_factor[3]=FS_Mask->ifh.scaling_factor[3];
  442. rsfrois->RSFMask->ifh.orientation=FS_Mask->ifh.orientation;
  444. printf("1\n");
  445. /* load in freesurfer region definition*/
  446. FSRegions = (char **)malloc((size_t)(16384*sizeof(char *)));
  447. if (!FSRegions) errm("Preprocess_RSF");
  448. fp = fopen(FSLUT,"r");
  449. if (!fp) errr("Preprocess_RSF",FSLUT);
  450. maxfsval=0;
  451. for (i=0; i<16384; i++) fsflag[i]=0;
  452. while (fgets(line, 512, fp)){
  453. if (line[0]>='0'&&line[0]<='9') {
  454. sscanf(line, "%d%s%*s", &maxfsval, otherstr);
  455. FSRegions[maxfsval]=(char *)malloc((size_t)(256*sizeof(char)));
  456. if (!FSRegions[maxfsval]) errm("Preprocess_RSF");
  457. strcpy(FSRegions[maxfsval], otherstr);
  458. fsflag[maxfsval]=1;
  459. printf("%s\t%d\n",FSRegions[maxfsval],maxfsval);
  460. /*nfsroi++;*/
  461. }
  462. }
  463. fclose(fp);
  464. printf("maxfsval=%d\n",maxfsval);
  466. /* combine FS_Mask, Head_Mask and PET_Mask to form RSFMask*/
  467. xb=FS_Mask->ifh.matrix_size[0]/4;
  468. yb=FS_Mask->ifh.matrix_size[1]/4;
  469. zb=FS_Mask->ifh.matrix_size[2]/4;
  470. fptr1=FS_Mask->image;
  471. fptr2=Head_Mask->image;
  472. fptr3=rsfrois->RSFMask->image;
  473. fptr4=PET_Mask->image;
  474. l=0;
  475. for (i=0; i<64; i++) oflag[i]=0; /*set all "other region" flags to be 0, no "other region" is defined at this point*/
  476. for (z=0;z<FS_Mask->ifh.matrix_size[2];z++) {
  477. for (y=0; y<FS_Mask->ifh.matrix_size[1]; y++) {
  478. for (x=0; x<FS_Mask->ifh.matrix_size[0]; x++) {
  479. tmp=x/xb+y/yb*4+z/zb*16;
  480. if (*fptr1>0 && *fptr4>0) { /*for voxels defined in FS_Mask and within PET field of view*/
  481. if (l<*fptr1) l=*fptr1;
  482. *fptr3=*fptr1;
  483. fsidx=(int)rint((double)*fptr1);
  484. if (fsflag[fsidx]<=0) { /*the fs region is undefined*/
  485. if (*fptr2>0) { /*within Head Mask*/
  486. *fptr3=(float)(tmp+16384);
  487. oflag[tmp]=1;
  488. } else {/*outside of Head Mask*/
  489. *fptr3=0;
  490. fsflag[0]=2;
  491. }
  492. } else { /* fs region is defined */
  493. fsflag[fsidx]=2;
  494. }
  495. } else if (*fptr1<=0&&*fptr2>0&&*fptr4>0) { /*outside of fs defined region, within Head Mask*/
  496. *fptr3=(float)(tmp+16384);
  497. oflag[tmp]=1;
  498. } else {
  499. *fptr3=0;
  500. fsflag[0]=2;
  501. }
  502. fptr1++;
  503. fptr2++;
  504. fptr3++;
  505. fptr4++;
  506. }
  507. }
  508. }
  509. nroi=0;
  510. maxfsval=(int)rint((double)l);
  511. printf("maxfsval=%d\n",maxfsval);
  512. printf("fsflag[%d]=%d\n",1999,fsflag[1999]);
  513. for (i=0; i<=maxfsval; i++) {
  514. if (fsflag[i]>1) {nroi++; printf("%s\t%d\n",FSRegions[i], i);}
  515. }
  516. printf("nroi=%d\n",nroi);
  517. for (i=0; i<64; i++) {
  518. if (oflag[i]>0) nroi++;
  519. }
  520. rsfrois->rois->NumberOfRegions=nroi;
  521. rsfrois->rois->List=(ROI_Info *)malloc((size_t)(nroi*sizeof(ROI_Info)));
  522. if (!rsfrois->rois->List) errm("Preprocess_RSF");
  523. k=0;
  524. for (i=0; i<=maxfsval; i++) {
  525. if (fsflag[i]>1) {
  526. strcpy(rsfrois->rois->List[k].Name, FSRegions[i]);
  527. rsfrois->rois->List[k].MaskVal=i;
  528. k++;
  529. }
  530. }
  531. for (i=0; i<64; i++) {
  532. if (oflag[i]>0) {
  533. sprintf(otherstr,"other%d",i+16384);
  534. strcpy(rsfrois->rois->List[k].Name, otherstr);
  535. rsfrois->rois->List[k].MaskVal=i+16384;
  536. k++;
  537. }
  538. }
  539. printf("%d\n",rsfrois->rois->NumberOfRegions);
  540. for (j=0; j<rsfrois->rois->NumberOfRegions; j++) {
  541. val = rsfrois->rois->List[j].MaskVal;
  542. fptr3 = rsfrois->RSFMask->image;
  543. for (i=0; i<nv; i++) {
  544. if (fabs(*fptr3-(float)val)<1e-4) {
  545. *fptr3=(float)j;
  546. }
  547. fptr3++;
  548. }
  549. }
  550. fptr3=rsfrois->RSFMask->image;
  551. l=(float)(rsfrois->rois->NumberOfRegions)-.5;
  552. for (i=0; i<nv; i++) {
  553. if (*fptr3>l) *fptr3=0;
  554. fptr3++;
  555. }
  556. for (i=0; i<nroi; i++) {rsfrois->rois->List[i].MaskVal=i; rsfrois->rois->List[i].NVoxels=0;}
  557. fptr3=rsfrois->RSFMask->image;
  558. for (i=0; i<nv; i++) {
  559. val=(int)rint((double)*fptr3);
  560. rsfrois->rois->List[val].NVoxels++;
  561. fptr3++;
  562. }
  563. return rsfrois;
  564. }
  566. RSFROIS *Preprocess_RSF2(IMAGE_4dfp *FS_Mask, IMAGE_4dfp *Head_Mask, RSFROIS *rsfrois, char *FSLUT)
  567. /*
  568. Combine Freesurfer defined masks, MR based head maskinto a RSF Mask.
  569. */
  570. {
  571. int i, j, k, nv, tmp, xb, yb, zb, x, y, z, FSVal[16384], nfsroi, nroi, fsflag[16384], oflag[64], fsidx, val, maxfsval;
  572. float *fptr1, *fptr2, *fptr3, l;
  573. char **FSRegions = NULL;
  574. char line[512], otherstr[256];
  575. FILE *fp = NULL;
  578. /* allocate memory and initiate rsfrois */
  579. nv=FS_Mask->ifh.number_of_bytes_per_pixel*FS_Mask->ifh.matrix_size[0]*FS_Mask->ifh.matrix_size[1]*FS_Mask->ifh.matrix_size[2]*FS_Mask->ifh.matrix_size[3];
  580. if (!rsfrois) {
  581. rsfrois=(RSFROIS *)malloc((size_t)sizeof(RSFROIS));
  582. if (!rsfrois) errm("Preprocess_RSF");
  583. rsfrois->RSFMask=(IMAGE_4dfp *)malloc((size_t)sizeof(IMAGE_4dfp));
  584. if (!rsfrois->RSFMask) errm("Preprocess_RSF");
  585. rsfrois->RSFMask->image=(float *)malloc((size_t)nv);
  586. if (!rsfrois->RSFMask->image) errm("Preprocess_RSF");
  587. rsfrois->rois=(ROIList *)malloc((size_t)sizeof(ROIList));
  588. if (!rsfrois->rois) errm("Preprocess_RSF");
  589. } else {
  590. nrerror("rsfrois should be a NULL pointer passing to Preprocess_RSF");
  591. }
  592. nv = nv/FS_Mask->ifh.number_of_bytes_per_pixel;
  593. strcpy(rsfrois->RSFMask->ifh.interfile, FS_Mask->ifh.interfile);
  594. strcpy(rsfrois->RSFMask->ifh.version_of_keys, FS_Mask->ifh.version_of_keys);
  595. strcpy(rsfrois->RSFMask->ifh.conversion_program, FS_Mask->ifh.conversion_program);
  596. strcpy(rsfrois->RSFMask->ifh.name_of_data_file, "RSFMask");
  598. strcpy(rsfrois->RSFMask->ifh.number_format, FS_Mask->ifh.number_format);
  599. strcpy(rsfrois->RSFMask->ifh.imagedata_byte_order, FS_Mask->ifh.imagedata_byte_order);
  600. rsfrois->RSFMask->ifh.number_of_bytes_per_pixel=FS_Mask->ifh.number_of_bytes_per_pixel;
  601. rsfrois->RSFMask->ifh.number_of_dimensions=FS_Mask->ifh.number_of_dimensions;
  602. for (i=0; i<3; i++)
  603. {
  604. rsfrois->RSFMask->ifh.matrix_size[i]=FS_Mask->ifh.matrix_size[i];
  605. rsfrois->RSFMask->ifh.scaling_factor[i]=FS_Mask->ifh.scaling_factor[i];
  606. rsfrois->RSFMask->ifh.mmppix[i]=FS_Mask->ifh.mmppix[i];
  607. rsfrois->RSFMask->ifh.center[i]=FS_Mask->ifh.center[i];
  608. }
  609. rsfrois->RSFMask->ifh.matrix_size[3]=FS_Mask->ifh.matrix_size[3];
  610. rsfrois->RSFMask->ifh.scaling_factor[3]=FS_Mask->ifh.scaling_factor[3];
  611. rsfrois->RSFMask->ifh.orientation=FS_Mask->ifh.orientation;
  614. /* load in freesurfer region definition*/
  615. FSRegions = (char **)malloc((size_t)(16384*sizeof(char *)));
  616. if (!FSRegions) errm("Preprocess_RSF");
  617. fp = fopen(FSLUT,"r");
  618. if (!fp) errr("Preprocess_RSF",FSLUT);
  619. maxfsval=0;
  620. for (i=0; i<16384; i++) fsflag[i]=0;
  621. while (fgets(line, 512, fp)){
  622. if (line[0]>='0'&&line[0]<='9') {
  623. sscanf(line, "%d%s%*s", &maxfsval, otherstr);
  624. FSRegions[maxfsval]=(char *)malloc((size_t)(256*sizeof(char)));
  625. if (!FSRegions[maxfsval]) errm("Preprocess_RSF");
  626. strcpy(FSRegions[maxfsval], otherstr);
  627. fsflag[maxfsval]=1;
  628. /*printf("%s\t%d\n",FSRegions[maxfsval],maxfsval);*/
  629. /*nfsroi++;*/
  630. }
  631. }
  632. fclose(fp);
  633. printf("maxfsval=%d\n",maxfsval);
  635. /* combine FS_Mask, Head_Mask to form RSFMask*/
  636. xb=FS_Mask->ifh.matrix_size[0]/4;
  637. yb=FS_Mask->ifh.matrix_size[1]/4;
  638. zb=FS_Mask->ifh.matrix_size[2]/4;
  639. fptr1=FS_Mask->image;
  640. fptr2=Head_Mask->image;
  641. fptr3=rsfrois->RSFMask->image;
  642. l=0;
  643. for (i=0; i<64; i++) oflag[i]=0; /*set all "other region" flags to be 0, no "other region" is defined at this point*/
  644. for (z=0;z<FS_Mask->ifh.matrix_size[2];z++) {
  645. for (y=0; y<FS_Mask->ifh.matrix_size[1]; y++) {
  646. for (x=0; x<FS_Mask->ifh.matrix_size[0]; x++) {
  647. tmp=x/xb+y/yb*4+z/zb*16;
  648. if (*fptr1>0 ) { /*for voxels defined in FS_Mask*/
  649. if (l<*fptr1) l=*fptr1;
  650. *fptr3=*fptr1;
  651. fsidx=(int)rint((double)*fptr1);
  652. if (fsflag[fsidx]<=0) { /*the fs region is undefined*/
  653. if (*fptr2>0) { /*within Head Mask*/
  654. *fptr3=(float)(tmp+16384);
  655. oflag[tmp]=1;
  656. } else {/*outside of Head Mask*/
  657. *fptr3=0;
  658. fsflag[0]=2;
  659. }
  660. } else { /* fs region is defined */
  661. fsflag[fsidx]=2;
  662. }
  663. } else if (*fptr1<=0&&*fptr2>0) { /*outside of fs defined region, within Head Mask*/
  664. *fptr3=(float)(tmp+16384);
  665. oflag[tmp]=1;
  666. } else {
  667. *fptr3=0;
  668. fsflag[0]=2;
  669. }
  670. fptr1++;
  671. fptr2++;
  672. fptr3++;
  673. }
  674. }
  675. }
  676. nroi=0;
  677. maxfsval=(int)rint((double)l);
  678. printf("maxfsval=%d\n",maxfsval);
  679. printf("fsflag[%d]=%d\n",1999,fsflag[1999]);
  680. for (i=0; i<=maxfsval; i++) {
  681. if (fsflag[i]>1) {nroi++; printf("%s\t%d\n",FSRegions[i], i);}
  682. }
  683. printf("nroi=%d\n",nroi);
  684. for (i=0; i<64; i++) {
  685. if (oflag[i]>0) nroi++;
  686. }
  687. rsfrois->rois->NumberOfRegions=nroi;
  688. rsfrois->rois->List=(ROI_Info *)malloc((size_t)(nroi*sizeof(ROI_Info)));
  689. if (!rsfrois->rois->List) errm("Preprocess_RSF");
  690. k=0;
  691. for (i=0; i<=maxfsval; i++) {
  692. if (fsflag[i]>1) {
  693. strcpy(rsfrois->rois->List[k].Name, FSRegions[i]);
  694. rsfrois->rois->List[k].MaskVal=i;
  695. k++;
  696. }
  697. }
  698. for (i=0; i<64; i++) {
  699. if (oflag[i]>0) {
  700. sprintf(otherstr,"other%d",i+16384);
  701. strcpy(rsfrois->rois->List[k].Name, otherstr);
  702. rsfrois->rois->List[k].MaskVal=i+16384;
  703. k++;
  704. }
  705. }
  706. printf("%d\n",rsfrois->rois->NumberOfRegions);
  707. for (j=0; j<rsfrois->rois->NumberOfRegions; j++) {
  708. val = rsfrois->rois->List[j].MaskVal;
  709. fptr3 = rsfrois->RSFMask->image;
  710. for (i=0; i<nv; i++) {
  711. if (fabs(*fptr3-(float)val)<1e-4) {
  712. *fptr3=(float)j;
  713. }
  714. fptr3++;
  715. }
  716. }
  717. fptr3=rsfrois->RSFMask->image;
  718. l=(float)(rsfrois->rois->NumberOfRegions)-.5;
  719. for (i=0; i<nv; i++) {
  720. if (*fptr3>l) *fptr3=0;
  721. fptr3++;
  722. }
  723. for (i=0; i<nroi; i++) {rsfrois->rois->List[i].MaskVal=i; rsfrois->rois->List[i].NVoxels=0;}
  724. fptr3=rsfrois->RSFMask->image;
  725. for (i=0; i<nv; i++) {
  726. val=(int)rint((double)*fptr3);
  727. rsfrois->rois->List[val].NVoxels++;
  728. fptr3++;
  729. }
  730. return rsfrois;
  731. }
  733. float *RSFPVC(RSFMat *RSFMat, float *roimean, int iters)
  734. /*
  735. RSFMat is a RSFMat structure that contains the matrix size n and a floating point matrix of n by n;
  736. roimean is a vector that counts from 1 to n;
  737. iters is the number of iterations to be performed using the iterative PVC algorithm;
  738. The return value is a pointer that points to a vector that counts from 1 to n
  739. */
  740. {
  741. int i, j, k, NROI;
  742. float *r, *val, *m;
  744. NROI=RSFMat->n;
  745. r=vector(1,NROI);
  746. val=vector(1,NROI);
  747. m=vector(1,NROI);
  748. for (i=1; i<=NROI; i++) {m[i]=roimean[i];} /* Initial estimation */
  749. for (k=0; k<iters; k++)
  750. {
  751. for (i=1; i<=NROI; i++){
  752. val[i]=0.;
  753. for (j=1; j<=NROI; j++) {
  754. val[i]+=m[j]*RSFMat->mat[j][i]; /* Blurred regional value assuming current estimation */
  755. }
  756. r[i]=fabs(roimean[i]/val[i]); /* ratio between reblurred value and observed value */
  757. r[i]= (r[i]<1.2)?r[i]:1.2; /* constraints for the ratio to be applied to avoid blow up */
  758. r[i]= (r[i]>0.8)?r[i]:0.8;
  759. }
  760. for (i=1; i<=NROI; i++) {
  761. m[i]=m[i]*r[i]; /* Apply correction for current iteration */
  762. }
  763. }
  765. free_vector(r, 1, NROI);
  766. free_vector(val, 1, NROI);
  767. return m;
  768. }
  770. void readtac(char *fn, float *tac, float *frd, float *st, float *nv, int *nframes)
  771. {
  772. FILE *fp;
  773. char line[MAXL], dummy[MAXL];
  774. float fdum, *fptr1, *fptr2, *fptr3, *fptr4;
  775. int i;
  777. if (!(fp=fopen(fn, "r"))) errr("readtac","fn");
  778. fgets(line, 512, fp);
  779. sscanf(line, "%s%s%s%s%s%f", dummy, dummy, dummy, dummy, dummy, nv);
  780. fptr3=tac;
  781. fptr2=frd;
  782. fptr1=st;
  783. *nframes=0;
  784. while(fgets(line, 512, fp))
  785. {
  786. sscanf(line, "%f%f%f%f", &fdum, fptr1, fptr2, fptr3);
  787. fptr1++;
  788. fptr2++;
  789. fptr3++;
  790. (*nframes)++;
  791. }
  792. fclose(fp);
  793. }

RSF.c at commit 746dd5d, under BSD-3-Clause · at the source

Overview

Authors: Marisa N. Denkinger1, Wagner S. Brum1,2, Antoine Leuzy1,2, Alpana Singh1, Taina M. Marques1, Valentina Ghisays3, Hillary Protas3, Yi Su3, Ali Atri1, Thomas G. Beach1, Geidy E. Serrano1, Kinal Bhatt4, Corey M. Carlson4, Katharine Hoffmann4, Eric M. Reiman3, Nicholas J. Ashton1,3
ORCID iDs: Marisa N. Denkinger
  1. Banner Sun Health Research Institute Sun City Arizona USA
  2. ZRO Imaging Santiago de Compostela Spain
  3. Banner Alzheimer's Institute Phoenix Arizona USA
  4. Beckman Coulter Inc. Chaska Minnesota USA
Institutions: Banner Sun Health Research Institute (United States); Banner Alzheimer’s Institute
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association, volume 22, issue 9, article e71773
Dates: received 25 February 2026; accepted 2 July 2026; published online 1 September 2026; in print September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/alz.71773 · PMID 42677463 · PMCID PMC13531372 · OpenAlex W7204906212
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), histology / microscopy (modality), PET / SPECT (modality), human (organism), Alzheimer's / dementia (population)
Methods: Connectivity, Statistics, fMRI & imaging
Keywords: Alzheimer's disease, amyloid, blood biomarkers, brain‐derived tau, diagnosis, neuropathology, phosphorylated tau, plasma biomarkers, p‐tau217
MeSH: Alzheimer Disease*, Brain*, tau Proteins*, Aged, Aged, 80 and over, Amyloid beta-Peptides, Biomarkers, Female, Humans, Male, Peptide Fragments, Phosphorylation, Positron-Emission Tomography (* major topic)
Topic: Alzheimer's disease research and treatments (Physiology, Medicine), according to OpenAlex
Funding: U.S. Department of Health & Human Services | NIH | National Institute of Neurological Disorders and Stroke (NINDS) (U24 NS072026); National Institute on Aging (P30 AG019610, P30AG072980); Arizona Department of Health Services (05700); Arizona Biomedical Research Commission (4001 0011 05‐901, 1001); Michael J. Fox Foundation for Parkinson's Research (CTR040636); Arizona Department of Health Services and Gates Ventures
Citations: not cited yet (Europe PMC); 38 references in the paper

Abstract

INTRODUCTION: Plasma phosphorylated tau (p‐tau), particularly p‐tau217, is a highly specific biomarker of Alzheimer's disease (AD) pathology. However, plasma p‐tau217 can be elevated in rare non‐AD conditions. Brain‐derived (BD) p‐tau217 may reduce these off‐target effects, but its performance against neuropathology has not been evaluated.

METHODS: We compared p‐tau217, BD p‐tau217, their amyloid beta 42 (Aβ42) ratios, BD p‐tau217/p‐tau217, and BD p‐tau217/BD tau in end‐of‐life plasma from 288 neuropathologically characterized participants using a fully automated immunoassay. Biomarkers were assessed against National Institute on Aging–Alzheimer's Association (NIA‐AA) classification, Thal phase, Braak stage, cognitive decline, and tau‐PET (positron emission tomography).

RESULTS: All markers tracked neuropathological severity, with BD p‐tau217 having larger fold‐changes than p‐tau217 but BD p‐tau217/Aβ42 enhancing this further. BD p‐tau217/BD tau achieved the highest area under the curve (AUC) for distinguishing Intermediate/High from Not/Low AD neuropathological change (ADNC) (0.89 vs 0.82 for p‐tau217). Although BD p‐tau217/p‐tau217 showed smaller fold‐changes, it had the strongest association with continuous tangle burden in AD (R2 = 0.68) and best predicted Clinical Dementia Rating Sum of Boxes (CDR‐SB decline) (R2 = 0.26).

DISCUSSION: BD p‐tau217 and BD‐based ratios enhance dynamic range and prognostic performance while maintaining diagnostic accuracy, supporting further clinical evaluation.

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.

ysu001/PUP

License: BSD-3-Clause
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 746dd5dce34807d85a820ac02aa22887a71005ed, 13 October 2020
Languages: C (198), C/C++ (66), MATLAB (10), Perl (1)
Size: 669 files, 275 scripts
Software Heritage: not archived
Found in: the text, “Tau‐PET imaging”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
277 files
At the source: github.com/ysu001/PUP

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;
  • 275 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.

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, 16 authors, 9 keywords, 13 MeSH terms, 6 funders, 37 references.

Cite

This paper

Denkinger, M. N., Brum, W. S., Leuzy, A., Singh, A., Marques, T. M., Ghisays, V., Protas, H., Su, Y., Atri, A., Beach, T. G., Serrano, G. E., Bhatt, K., Carlson, C. M., Hoffmann, K., Reiman, E. M., & Ashton, N. J. (2026). Brain-derived plasma p-tau217 shows enhanced dynamic range for Alzheimer's disease neuropathological change. Alzheimer's & dementia : the journal of the Alzheimer's Association, 22(9), e71773. https://doi.org/10.1002/alz.71773

BibTeX

@article{denkinger2026brain,
author = {Denkinger, Marisa N. and Brum, Wagner S. and Leuzy, Antoine and Singh, Alpana and Marques, Taina M. and Ghisays, Valentina and Protas, Hillary and Su, Yi and Atri, Ali and Beach, Thomas G. and Serrano, Geidy E. and Bhatt, Kinal and Carlson, Corey M. and Hoffmann, Katharine and Reiman, Eric M. and Ashton, Nicholas J.},
title = {{Brain-derived plasma p-tau217 shows enhanced dynamic range for Alzheimer's disease neuropathological change}},
journal = {Alzheimer's \& dementia : the journal of the Alzheimer's Association},
year = {2026},
month = sep,
volume = {22},
number = {9},
pages = {e71773},
publisher = {Wiley},
issn = {1552-5260},
doi = {10.1002/alz.71773},
url = {https://doi.org/10.1002/alz.71773},
pmid = {42677463},
pmcid = {PMC13531372}
}

RIS

TY - JOUR
AU - Denkinger, Marisa N.
AU - Brum, Wagner S.
AU - Leuzy, Antoine
AU - Singh, Alpana
AU - Marques, Taina M.
AU - Ghisays, Valentina
AU - Protas, Hillary
AU - Su, Yi
AU - Atri, Ali
AU - Beach, Thomas G.
AU - Serrano, Geidy E.
AU - Bhatt, Kinal
AU - Carlson, Corey M.
AU - Hoffmann, Katharine
AU - Reiman, Eric M.
AU - Ashton, Nicholas J.
TI - Brain-derived plasma p-tau217 shows enhanced dynamic range for Alzheimer's disease neuropathological change
T2 - Alzheimer's & dementia : the journal of the Alzheimer's Association
J2 - Alzheimers Dement
PY - 2026
DA - 2026/09/01
VL - 22
IS - 9
SP - e71773
SN - 1552-5260
PB - Wiley
DO - 10.1002/alz.71773
UR - https://doi.org/10.1002/alz.71773
LA - en
ER -

CSL-JSON

{
"id": "10.1002/alz.71773",
"type": "article-journal",
"title": "Brain-derived plasma p-tau217 shows enhanced dynamic range for Alzheimer's disease neuropathological change",
"container-title": "Alzheimer's & dementia : the journal of the Alzheimer's Association",
"author": [
{
"family": "Denkinger",
"given": "Marisa N."
},
{
"family": "Brum",
"given": "Wagner S."
},
{
"family": "Leuzy",
"given": "Antoine"
},
{
"family": "Singh",
"given": "Alpana"
},
{
"family": "Marques",
"given": "Taina M."
},
{
"family": "Ghisays",
"given": "Valentina"
},
{
"family": "Protas",
"given": "Hillary"
},
{
"family": "Su",
"given": "Yi"
},
{
"family": "Atri",
"given": "Ali"
},
{
"family": "Beach",
"given": "Thomas G."
},
{
"family": "Serrano",
"given": "Geidy E."
},
{
"family": "Bhatt",
"given": "Kinal"
},
{
"family": "Carlson",
"given": "Corey M."
},
{
"family": "Hoffmann",
"given": "Katharine"
},
{
"family": "Reiman",
"given": "Eric M."
},
{
"family": "Ashton",
"given": "Nicholas J."
}
],
"container-title-short": "Alzheimers Dement",
"volume": "22",
"issue": "9",
"page": "e71773",
"DOI": "10.1002/alz.71773",
"PMID": "42677463",
"PMCID": "PMC13531372",
"ISSN": "1552-5260",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/alz.71773",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
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.1093/brain/awaf375 [code]
Reference proteins to improve Core 1 and Core 2 Alzheimer's disease CSF and plasma biomarkers.
Journal: Brain : a journal of neurology
In common: PET / SPECT, other, Alzheimer's / dementia, 6 references
[2] doi:10.1002/alz.71711 [code]
Exploring longitudinal relationships among Alzheimer's disease biomarkers.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: PET / SPECT, other, Alzheimer's / dementia, 5 references
[3] doi:10.1002/ana.78300
Distribution of Big Tau Isoforms in the Human Central and Peripheral Nervous System.
Journal: Annals of neurology
In common: other, Alzheimer's / dementia, 5 references
[4] doi:10.1186/s13195-026-02119-z
Age-dependent diagnostic and correlational architecture of multiplex plasma biomarkers in Alzheimer's disease: a cross-ethnic, cross-platform validation study.
Journal: Alzheimer's research & therapy
In common: PET / SPECT, other, Alzheimer's / dementia, 5 references
[5] doi:10.1002/acn3.70423
Impact of Plasma p-tau181 on Cognition, Motor Phenotypes, and Disease Course in ALS.
Journal: Annals of clinical and translational neurology
In common: other, Alzheimer's / dementia, 5 references
[6] doi:10.1002/alz.71530 [code]
Differential associations of plasma biomarkers with Alzheimer's disease and small vessel disease: A multimodal imaging study.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: PET / SPECT, other, Alzheimer's / dementia, 4 references
[7] doi:10.64898/2026.05.06.26352540 [code]
Generating synthetic tau-PET scans in Alzheimer’s disease from MRI, blood biomarkers and demographics with deep learning
Journal: medRxiv (preprint)
In common: PET / SPECT, other, Alzheimer's / dementia, 4 references
[8] doi:10.1093/brain/awaf413 [code]
Estimating the time course of biomarker changes in Alzheimer's disease.
Journal: Brain : a journal of neurology
In common: PET / SPECT, Alzheimer's / dementia, 4 references
[9] doi:10.1007/s00401-026-03042-1
Tau368 improves p-tau diagnostic accuracy for FTLD-tau from FTLD-TDP.
Journal: Acta neuropathologica
In common: Alzheimer's / dementia, 4 references
[10] doi:10.1002/hbm.70508 [code]
Cyclic 2.5D Perceptual Loss for Cross-Modal 3D Medical Image Synthesis: T1w MRI to Tau PET.
Journal: Human brain mapping
In common: PET / SPECT, Alzheimer's / dementia, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

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.