OSCR

aDISCO: A clearing method to enable 3D microscopy of large archival paraffin-embedded human tissue blocks.

Code ↔ Paper

3 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 3 matches
  1. [1] § MATERIALS AND METHODS › Neuronal cell segmentation and detection ↔ Gradient_cell_merger/Batch_processing_gradient_merger.py, lines 5–28 · score 0.87 · gradient ascent, ClearMap, binary classifier, cell detection, pixels, location
  2. [2] § MATERIALS AND METHODS › Neuronal cell segmentation and detection ↔ Binary_classification_neuron_candidates/Train_binary_classification_2DCNN.py, lines 255–296 · score 0.76 · cross entropy loss, binary classifier, Adagrad, ensembles, train, optimized
  3. [3] § RESULTS › 3D cortical profiling of neuronal density in archival human brain ↔ Gradient_cell_merger/Batch_processing_gradient_merger.py, lines 5–28 · score 0.59 · deep learning, ClearMap, cell detection, mapping, discarded, Raw

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 423 lines · 15 KB · GPL-3.0 · 2 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  5. """
  6. Created on Tue Feb 28 22:43:03 2023
  8. @author: Peter Rupprecht, [email hidden]
  10. # ============================================================================
  11. # Script for merging (elimination of splitter cells)
  12. #
  13. # The script takes each detected point as a candidate and looks for neighboring
  14. # pixels that are brighter. It continues to do so (gradient ascent) until a peak is reached
  15. # This peak is taken as the new location of the cell
  16. # Then, duplicate cell locations (same peak reached) are taken as a single cell
  17. # Finally, a deep-learning based classifier is applied to only keep cells and discard non-cells
  18. # =============================================================================
  21. Please change "folder_name" according to the local paths on your computer
  23. Also, change the filenames for "parent_folder_patients" and "filenames_patients" so that they match the raw data and the list of cells detected via ClearMap.
  25. """
  28. folder_name = '/home/helios/Desktop/Cell_Detection/Binary_classification_neuron_candidates'
  32. # import packages
  33. import numpy as np
  34. import glob, os, time, tifffile, copy
  35. from scipy import ndimage
  36. from skimage import segmentation
  37. from skimage.morphology import binary_dilation, ball
  38. from skimage import measure
  39. #from numba import jit
  41. import matplotlib.pyplot as plt
  44. # dependencies for the classifier
  45. import torch
  46. import torch.optim as optim
  47. import torch.nn as nn
  48. import torch.nn.functional as F
  50. import os, glob
  51. import numpy as np
  53. import copy
  55. """
  57. Define Convolutional Neural Networks
  60. """
  63. class Net(nn.Module):
  64. def __init__(self):
  65. super().__init__()
  66. self.conv1 = nn.Conv2d(1, 6, (7,3))
  67. self.pool = nn.MaxPool2d(2, 2)
  68. self.conv2 = nn.Conv2d(6, 16, (7,3))
  69. self.fc1 = nn.Linear(1728, 120)
  70. self.fc2 = nn.Linear(120, 84)
  71. self.fc3 = nn.Linear(84, 2)
  73. def forward(self, x):
  74. x = self.pool(F.relu(self.conv1(x)))
  75. x = self.pool(F.relu(self.conv2(x)))
  76. x = torch.flatten(x, 1) # flatten all dimensions except batch
  77. x = F.relu(self.fc1(x))
  78. x = F.relu(self.fc2(x))
  79. x = self.fc3(x)
  80. return x
  82. class Net_xy(nn.Module):
  83. def __init__(self):
  84. super().__init__()
  85. self.conv1 = nn.Conv2d(1, 6, 3)
  86. self.pool = nn.MaxPool2d(2, 2)
  87. self.conv2 = nn.Conv2d(6, 16, 3)
  88. self.fc1 = nn.Linear(576, 120)
  89. self.fc2 = nn.Linear(120, 84)
  90. self.fc3 = nn.Linear(84, 2)
  92. def forward(self, x):
  93. x = self.pool(F.relu(self.conv1(x)))
  94. x = self.pool(F.relu(self.conv2(x)))
  95. x = torch.flatten(x, 1) # flatten all dimensions except batch
  96. x = F.relu(self.fc1(x))
  97. x = F.relu(self.fc2(x))
  98. x = self.fc3(x)
  99. return x
  102. # indicate folder and file names
  104. parent_folder_patients = '/media/helios/SpeedDisk/FCD_Stitched/FCD_SampleAnalysis_Crop/FCD_Patients/'
  105. filenames_patients = glob.glob(parent_folder_patients+'/FCD_CX_2.*_NeuN-Cy3/*NeuN-*-*.tif')
  107. filenames_all = filenames_patients
  109. for file_index,filename in enumerate(filenames_all):
  111. BaseDirectory = os.path.dirname(filename)
  113. cFosFile = os.path.join(filename)
  114. point_list = cFosFile[:-4]+'_cells-allpoints.npy'
  116. file_size = os.path.getsize(cFosFile)
  117. print('Processing the next file. Progress: '+str(100*(file_index+1)/len(filenames_all))+'%')
  118. file_size = np.round(file_size/1024**3)
  119. print("File Size is :", file_size, "GB")
  121. os.chdir(BaseDirectory)
  122. print('Processing the following folder: '+BaseDirectory)
  124. if os.path.isfile(point_list) and file_index >= 0 and file_size < 45:
  126. raw_data_filename = cFosFile
  129. detected_points_filename = point_list # result from ClearMap
  131. # load data
  132. raw_data = np.array(tifffile.imread(raw_data_filename))
  133. detected_points = np.load(detected_points_filename)
  135. detected_points_old = copy.deepcopy(detected_points)
  136. detected_points_new = detected_points
  138. print('Process '+str(len(detected_points))+' points with gradient-based peak-finder.')
  142. # gradient search takes about 80 s for 50k points, i.e., typically around 20-40 min for a sample with 1M-2M detected points
  144. # go through all cell candidates
  145. for points in np.arange(detected_points.shape[0]):
  147. if np.mod(points,50000) == 0:
  148. print(str(points)+' out of '+str(detected_points.shape[0]))
  150. starting_point0 = detected_points[points,:].astype(int)[::-1]
  152. cube_size = 15
  153. low_z0 = max(0,starting_point0[0]-cube_size*3) # anisotropy of search environment^
  154. high_z0 = min(starting_point0[0]+cube_size*3+1,raw_data.shape[0])
  155. low_y0 = max(0,starting_point0[1]-cube_size)
  156. high_y0 = min(starting_point0[1]+cube_size+1,raw_data.shape[1])
  157. low_x0 = max(0,starting_point0[2]-cube_size)
  158. high_x0 = min(starting_point0[2]+cube_size+1,raw_data.shape[2])
  159. larger_environment = np.array(raw_data[low_z0:high_z0,low_y0:high_y0,low_x0:high_x0]).astype(float)
  162. larger_environmentX = ndimage.gaussian_filter(larger_environment.astype(float),[2.5,1,1]) # anisotropy of smoothing
  164. focus_point = np.zeros((3,),dtype='int')
  165. for dimension in np.arange(3):
  166. if dimension == 0: # anisotropy of search environment^
  167. scale = 3
  168. else:
  169. scale = 1
  170. if starting_point0[dimension] - cube_size*scale < 0:
  171. focus_point[dimension] = starting_point0[dimension]
  172. else:
  173. focus_point[dimension] = cube_size*scale
  175. focus_point_initial = copy.deepcopy(focus_point)
  177. # until no further increase of fluorescence seen
  179. stop_criterion = 0
  180. while not stop_criterion:
  182. # extract local environment of seed point
  184. low_z = max(0,focus_point[0]-1)
  185. high_z = min(focus_point[0]+2,larger_environmentX.shape[0])
  186. low_y = max(0,focus_point[1]-1)
  187. high_y = min(focus_point[1]+2,larger_environmentX.shape[1])
  188. low_x = max(0,focus_point[2]-1)
  189. high_x = min(focus_point[2]+2,larger_environmentX.shape[2])
  191. environment = np.array(larger_environmentX[low_z:high_z,low_y:high_y,low_x:high_x]).astype(float)
  193. # find location of maximum value in neighborhood
  194. indices = np.array(np.unravel_index(np.argmax(environment), environment.shape))
  196. # backup
  197. old_focus_point = copy.deepcopy(focus_point)
  198. # update
  199. focus_point = ([low_z,low_y,low_x] + indices).astype(int)
  202. # if stopping criterion reached
  203. if larger_environmentX[focus_point[0],focus_point[1],focus_point[2]] == larger_environmentX[old_focus_point[0],old_focus_point[1],old_focus_point[2]]:
  204. stop_criterion = 1
  207. # write back in reverse order (z,y,x) --> (x,y,z)
  208. detected_points_new[points,:] = focus_point[::-1] - focus_point_initial[::-1] + starting_point0[::-1]
  210. # print(np.sqrt(np.sum((focus_point - focus_point_initial)**2)))
  212. # discard duplicates (cell seeds that arrive at the same local maximum)
  213. detected_points_new = np.unique(detected_points_new,axis = 0)
  214. print('Found and kept '+str(len(detected_points_new))+' points.')
  217. # Go through batches and apply pretrained binary classifier
  218. accept_cell_candidates = np.zeros((detected_points_new.shape[0],))
  219. confidence_acceptance_all = np.zeros((detected_points_new.shape[0],))
  220. batch_size = 5000
  221. nb_chunks = np.ceil(len(detected_points_new)/batch_size)
  223. for batch in np.arange(nb_chunks):
  225. print('Batch '+str(int(batch+1))+' out of '+str(int(nb_chunks)))
  227. # get indices of neuron candidates for this batch
  228. indices = np.arange(int(batch*batch_size),int(min(batch*batch_size + batch_size,len(detected_points_new)) ))
  230. # pre-allocate array
  231. all_environments = np.zeros((len(indices),91,31,31))
  233. for k in np.arange(len(indices)):
  235. starting_point0 = detected_points_new[indices[k],:].astype(int)[::-1]
  237. # get boundaries of the cube
  238. cube_size = 15
  239. low_z0 = max(0,starting_point0[0]-cube_size*3) # anisotropy of search environment^
  240. high_z0 = min(starting_point0[0]+cube_size*3+1,raw_data.shape[0])
  241. low_y0 = max(0,starting_point0[1]-cube_size)
  242. high_y0 = min(starting_point0[1]+cube_size+1,raw_data.shape[1])
  243. low_x0 = max(0,starting_point0[2]-cube_size)
  244. high_x0 = min(starting_point0[2]+cube_size+1,raw_data.shape[2])
  246. larger_environment = np.array(raw_data[low_z0:high_z0,low_y0:high_y0,low_x0:high_x0]).astype(float)
  248. # in case the cube is cut off by the stack boundaries, pad with a reflection
  249. lz_plus = -min(0,starting_point0[0]-cube_size*3)
  250. ly_plus = -min(0,starting_point0[1]-cube_size)
  251. lx_plus = -min(0,starting_point0[2]-cube_size)
  252. hz_plus = -min(0,raw_data.shape[0] - (starting_point0[0]+cube_size*3+1))
  253. hy_plus = -min(0,raw_data.shape[1] - (starting_point0[1]+cube_size+1))
  254. hx_plus = -min(0,raw_data.shape[2] - (starting_point0[2]+cube_size+1))
  256. # perform padding
  257. larger_environment_padded = np.pad(larger_environment, [(lz_plus,hz_plus), (ly_plus,hy_plus), (lx_plus,hx_plus)], 'reflect')
  259. all_environments[k,:,:,:] = larger_environment_padded
  261. # adapt dimensionality of the matrix to create a suited input for the network
  262. all_environments = np.expand_dims(all_environments,1)
  264. # folder where pretrained networks are stored
  265. model_folder = os.path.join(folder_name,'trained_models')
  267. # get classification from the xy-view
  268. net_xy = Net_xy()
  269. models_xy = glob.glob(os.path.join(model_folder,'Model_xy*'))
  271. for kk,model in enumerate(models_xy):
  273. net_xy.load_state_dict(torch.load(model))
  275. input_data_xy = copy.deepcopy(all_environments[:,:,45,:,:])
  276. for k in np.arange(input_data_xy.shape[0]):
  277. input_data_xy[k,:,:,:] = (input_data_xy[k,:,:,:] - np.nanmean(input_data_xy[k,:,:,:]))/np.nanstd(input_data_xy[k,:,:,:])
  278. inputs = torch.from_numpy(input_data_xy[:,:,:,:])
  280. net_xy.eval()
  281. outputs = net_xy(inputs.float())
  283. if kk == 0:
  284. outputs_test_all = outputs.detach().numpy()
  285. else:
  286. outputs_test_all += outputs.detach().numpy()
  288. # get classification from the xz-view
  289. net_xz = Net()
  290. models_xz = glob.glob(os.path.join(model_folder,'Model_xz*'))
  292. for kk,model in enumerate(models_xz):
  294. net_xz.load_state_dict(torch.load(model))
  296. input_data_xz = copy.deepcopy(all_environments[:,:,:,15,:])
  297. for k in np.arange(input_data_xz.shape[0]):
  298. input_data_xz[k,:,:,:] = (input_data_xz[k,:,:,:] - np.nanmean(input_data_xz[k,:,:,:]))/np.nanstd(input_data_xz[k,:,:,:])
  299. inputs = torch.from_numpy(input_data_xz[:,:,:,:])
  301. net_xz.eval()
  302. outputs = net_xz(inputs.float())
  304. if 0:
  305. outputs_test_all = outputs.detach().numpy()
  306. else:
  307. outputs_test_all += outputs.detach().numpy()
  309. # get classification from the yz-view
  310. net_yz = Net()
  311. models_yz = glob.glob(os.path.join(model_folder,'Model_yz*'))
  313. performance = np.zeros((len(models_yz),1))
  314. for kk,model in enumerate(models_yz):
  316. net_yz.load_state_dict(torch.load(model))
  318. input_data_yz = copy.deepcopy(all_environments[:,:,:,:,15])
  319. for k in np.arange(input_data_yz.shape[0]):
  320. input_data_yz[k,:,:,:] = (input_data_yz[k,:,:,:] - np.nanmean(input_data_yz[k,:,:,:]))/np.nanstd(input_data_yz[k,:,:,:])
  321. inputs = torch.from_numpy(input_data_yz[:,:,:,:])
  323. net_yz.eval()
  324. outputs = net_yz(inputs.float())
  326. if 0:
  327. outputs_test_all = outputs.detach().numpy()
  328. else:
  329. outputs_test_all += outputs.detach().numpy()
  331. # combine classifications and use cutoff (chosen by manual inspection)
  332. confidence_acceptance = outputs_test_all[:,1] - outputs_test_all[:,0]
  334. accept_cell_candidates_this_batch = confidence_acceptance > 30
  336. accept_cell_candidates[indices] = accept_cell_candidates_this_batch
  337. confidence_acceptance_all[indices] = confidence_acceptance
  339. # keep only points classified as neurons by the 2D-CNN
  341. confidence_acceptance_all_selected = confidence_acceptance_all[accept_cell_candidates.astype(np.bool)]
  342. detected_points_new_reduced = detected_points_new[accept_cell_candidates.astype(np.bool)]
  343. print('Kept '+str(len(detected_points_new_reduced))+' points after thresholding.')
  346. points = detected_points_new_reduced
  349. # remove duplicates (adjacent labels of the same neuron)
  351. for point_index in np.arange(len(points)):
  353. if np.mod(point_index,50000) == 0:
  354. print('Progress for proximity pruning: '+str(point_index/len(points)*100))
  356. point = points[point_index,:]
  358. dist = np.linalg.norm(points-point,axis=1)
  359. discard = np.sum(np.logical_and(dist<=5,dist>0.5))
  360. if discard > 0:
  361. points[point_index,:] = [-10,-10,-10]
  363. correct_indices = points[:,1] > -10
  365. points = points[correct_indices,:]
  366. confidence_acceptance_all_selected = confidence_acceptance_all_selected[correct_indices,]
  369. # make a test stack for visualization
  370. if 1:
  371. print('Make a tif-file to check quality of cell detection.')
  373. # make a tif file to check back
  374. detected_points_new_int = points.astype(int)
  375. points_data = np.zeros((raw_data.shape))
  376. for k in np.arange(detected_points_new_int.shape[0]):
  377. points_data[detected_points_new_int[k,2],detected_points_new_int[k,1],detected_points_new_int[k,0]] += 1
  379. points_data = points_data.astype(raw_data.dtype) * raw_data.max();
  380. raw_data.shape = raw_data.shape + (1,);
  381. points_data.shape = points_data.shape + (1,);
  382. points_data = np.concatenate((raw_data, points_data), axis = 3);
  384. import tifffile as tiff
  386. filename = cFosFile[:-4]+'check_cells_gradient_plus_classifier_undoubled.tif'
  387. tiff.imsave(filename, points_data.transpose([0,1,2,3]), photometric = 'minisblack', planarconfig = 'contig', bigtiff = True)
  389. print('Save detected cells to a numpy file.')
  391. else:
  392. print('No file saved.')
  394. try:
  395. del points_data
  396. del raw_data
  397. del raw_dataX
  398. del X
  399. del marker_stack
  400. except:
  401. pass
  402. # save results to a numpy or mat file
  403. print('Save detected cells to a numpy file.')
  407. filename_points_after_gradient_corrected = cFosFile[:-4]+'_points_gradient_plus_classifier_corrected.mat'
  409. import scipy.io as sio
  411. sio.savemat(filename_points_after_gradient_corrected,{'points':points,'confidence_acceptance_all_selected':confidence_acceptance_all_selected})
  413. print('Done with this stack.\n')
  416. else:
  418. print('These files have not been processed with Ilastik before; or were manually excluded from processing.\n')

Batch_processing_gradient_merger.py at commit 0a92e5a, under GPL-3.0 · at the source

Overview

Authors: Anna Maria Reuss1,2,3, Dominik Groos2, Martina Cerisoli1, Lena Nordberg1, Lukas Frick1, Fabian F Voigt2, Nikita Vladimirov2,4,5, Philipp Bethge2, Regina Reimann1, Fritjof Helmchen2,3,4, Peter Rupprecht2,3, Adriano Aguzzi6
ORCID iDs: Anna Maria Reuss, Dominik Groos, Lena Nordberg, Lukas Frick, Fabian F Voigt, Nikita Vladimirov, Philipp Bethge, Regina Reimann, Fritjof Helmchen, Peter Rupprecht, Adriano Aguzzi
  1. Institute of Neuropathology, University Hospital Zurich, Schmelzbergstrasse 12, 8091 Zurich, Switzerland
  2. Brain Research Institute, University of Zurich, Winterthurerstrasse 190, 8057 Zurich, Switzerland
  3. Neuroscience Center Zurich, University of Zurich, Winterthurerstrasse 190, 8057 Zurich, Switzerland
  4. University Research Priority Program (URPP), Adaptive Brain Circuits in Development and Learning, University of Zurich, Zurich, Switzerland
  5. Center for Microscopy and Image Analysis (ZMB), University of Zurich, Winterthurerstrasse 190, 8057 Zurich, Switzerland
  6. Institute for the Science of the Aging Brain (ISAB), Lerchenfeldstrasse 3, 9014 St. Gallen, Switzerland
Institutions: University of Zurich (Switzerland); University Hospital Zurich (Switzerland); Center for Microscopy and Image Analysis (Switzerland); ISAB - Institute for the Science of the Aging Brain (Switzerland)
Journal: Science advances, volume 12, issue 33, article eaef9926
Dates: received 2 February 2026; accepted 7 July 2026; published online 12 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1126/sciadv.aef9926 · PMID 42585329 · PMCID PMC13464637 · OpenAlex W7202264078
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), human (organism), methods / tools (subfield)
Methods: Connectivity, Statistics, Machine learning, fMRI & imaging, Preprocessing
MeSH: Imaging, Three-Dimensional*, Microscopy*, Paraffin Embedding*, Deep Learning, Humans, Tissue Fixation (* major topic)
Topic: Cell Image Analysis Techniques (Biophysics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Swiss National Science Foundation (209114)
Citations: not cited yet (Europe PMC); 79 references in the paper

Abstract

Human surgery and autopsy specimens are routinely stored as formalin-fixed paraffin-embedded (FFPE) tissue blocks for decades, creating vast archives of healthy and diseased tissues. While tissue clearing and whole-mount microscopy enable 3D analysis, FFPE human tissue blocks are often unsuitable for clearing and immunolabeling due to their large size and extensive cross-linking. Here, we introduce “archival” DISCO (aDISCO), a clearing method designed to overcome these challenges. aDISCO achieves effective clearing and immunolabeling of large samples stored for 15 years or more. We applied aDISCO to human brain, spinal cord, peripheral nerve, skin, muscle, heart, kidney, liver, spleen, colon, and lung, using a broad range of antibodies. Combining aDISCO with deep learning–based analysis to study focal cortical dysplasia (FCD), we found disrupted cortical layering with both focal and global neuronal density variations, features likely to be overlooked by conventional histology. In summary, aDISCO delivers datasets suitable for deep learning–based processing, enabling the detection of subtle and sparse pathologies in large archival human tissue specimens.

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

Repositories

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

ptrrupprecht/cell_detection

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0a92e5a6f6b29e22e18a9804fe82959ea1986f60, 12 August 2026
Languages: Python (4)
Size: 46 files, 4 scripts
Software Heritage: not archived
Found in: the text, “Neuronal cell segmentation and detection”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (4 files), PyTorch (3 files), Matplotlib (2 files), scikit-image (1 file), scikit-learn (1 file), SciPy (1 file), tifffile (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/PTRRupprecht/Cell_Detection/tree/main/Gradient_cell_merger

Zenodo 20443377

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data, code, and materials availability:”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.5281/zenodo.20443377

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 4 scripts, each with its path and the digest of its content;
  • 3 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data, code, and materials availability

All data and code needed to evaluate and reproduce the results in the paper are present in the paper and/or the Supplementary Materials. The codes are publicly available on Zenodo (https://doi.org/10.5281/zenodo.20443377) (79). This study did not generate new materials.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 12 authors, 6 MeSH terms, 1 funder, 71 references.

Cite

This paper

Reuss, A. M., Groos, D., Cerisoli, M., Nordberg, L., Frick, L., Voigt, F. F., Vladimirov, N., Bethge, P., Reimann, R., Helmchen, F., Rupprecht, P., & Aguzzi, A. (2026). aDISCO: A clearing method to enable 3D microscopy of large archival paraffin-embedded human tissue blocks. Science advances, 12(33), eaef9926. https://doi.org/10.1126/sciadv.aef9926

BibTeX

@article{reuss2026adisco,
author = {Reuss, Anna Maria and Groos, Dominik and Cerisoli, Martina and Nordberg, Lena and Frick, Lukas and Voigt, Fabian F and Vladimirov, Nikita and Bethge, Philipp and Reimann, Regina and Helmchen, Fritjof and Rupprecht, Peter and Aguzzi, Adriano},
title = {{aDISCO: A clearing method to enable 3D microscopy of large archival paraffin-embedded human tissue blocks}},
journal = {Science advances},
year = {2026},
month = aug,
volume = {12},
number = {33},
pages = {eaef9926},
publisher = {American Association for the Advancement of Science},
issn = {2375-2548},
doi = {10.1126/sciadv.aef9926},
url = {https://doi.org/10.1126/sciadv.aef9926},
pmid = {42585329},
pmcid = {PMC13464637}
}

RIS

TY - JOUR
AU - Reuss, Anna Maria
AU - Groos, Dominik
AU - Cerisoli, Martina
AU - Nordberg, Lena
AU - Frick, Lukas
AU - Voigt, Fabian F
AU - Vladimirov, Nikita
AU - Bethge, Philipp
AU - Reimann, Regina
AU - Helmchen, Fritjof
AU - Rupprecht, Peter
AU - Aguzzi, Adriano
TI - aDISCO: A clearing method to enable 3D microscopy of large archival paraffin-embedded human tissue blocks
T2 - Science advances
J2 - Sci Adv
PY - 2026
DA - 2026/08/12
VL - 12
IS - 33
SP - eaef9926
SN - 2375-2548
PB - American Association for the Advancement of Science
DO - 10.1126/sciadv.aef9926
UR - https://doi.org/10.1126/sciadv.aef9926
LA - en
ER -

CSL-JSON

{
"id": "10.1126/sciadv.aef9926",
"type": "article-journal",
"title": "aDISCO: A clearing method to enable 3D microscopy of large archival paraffin-embedded human tissue blocks",
"container-title": "Science advances",
"author": [
{
"family": "Reuss",
"given": "Anna Maria"
},
{
"family": "Groos",
"given": "Dominik"
},
{
"family": "Cerisoli",
"given": "Martina"
},
{
"family": "Nordberg",
"given": "Lena"
},
{
"family": "Frick",
"given": "Lukas"
},
{
"family": "Voigt",
"given": "Fabian F"
},
{
"family": "Vladimirov",
"given": "Nikita"
},
{
"family": "Bethge",
"given": "Philipp"
},
{
"family": "Reimann",
"given": "Regina"
},
{
"family": "Helmchen",
"given": "Fritjof"
},
{
"family": "Rupprecht",
"given": "Peter"
},
{
"family": "Aguzzi",
"given": "Adriano"
}
],
"container-title-short": "Sci Adv",
"volume": "12",
"issue": "33",
"page": "eaef9926",
"DOI": "10.1126/sciadv.aef9926",
"PMID": "42585329",
"PMCID": "PMC13464637",
"ISSN": "2375-2548",
"publisher": "American Association for the Advancement of Science",
"URL": "https://doi.org/10.1126/sciadv.aef9926",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
12
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: tifffile, scikit-image, PyTorch, 4 other tools, histology / microscopy, methods / tools, 2 references
[2] doi:10.1038/s41598-026-51531-w [code]
Multimodal age-dependent diffusion-MRI analysis of the neocortex in a rat model of cortical dysplasia.
Journal: Scientific reports
In common: tifffile, scikit-image, scikit-learn, 3 other tools, 3 references
[3] doi:10.1038/s41467-026-73476-4 [code]
Developmental molecular signatures define de novo cortico-brainstem circuit for skilled forelimb movement.
Journal: Nature communications
In common: tifffile, scikit-image, PyTorch, 2 other tools, 3 references
[4] doi:10.1016/j.isci.2026.117010 [code]
Deep learning-assisted mapping of dendritic spines using sequential 2D two-photon calcium imaging.
Journal: iScience
In common: tifffile, scikit-image, PyTorch, 4 other tools, histology / microscopy, 1 reference
[5] doi:10.1002/hipo.70124 [code]
Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults.
Journal: Hippocampus
In common: tifffile, scikit-image, PyTorch, 4 other tools, 1 reference
[6] doi:10.1016/j.adro.2026.102092 [code]
Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.
Journal: Advances in radiation oncology
In common: tifffile, scikit-image, PyTorch, 4 other tools, 1 reference
[7] doi:10.1126/sciadv.aec4911 [code]
Dendritic shaft constrictions shape synaptic integration in neurons.
Journal: Science advances
In common: SciPy, Matplotlib, NumPy, 1 reference, author Philipp Bethge
[8] doi:10.1016/j.isci.2026.116206 [code]
Gut distension evokes rapid neural dynamics in vagal and hindbrain populations of larval zebrafish.
Journal: iScience
In common: tifffile, scikit-image, PyTorch, 4 other tools, 1 reference
[9] doi:10.64898/2026.03.30.715222 [code]
Synthetic lumen rounding directs neural progenitor division mode
Journal: bioRxiv (preprint)
In common: tifffile, scikit-image, PyTorch, 4 other tools, 1 reference
[10] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: tifffile, scikit-image, PyTorch, 4 other tools, methods / tools

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.