OSCR

Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex.

Code ↔ Paper

2 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 2 matches
  1. [1] § METHODS › Image analysis ↔ src/functions.py, lines 451–529 · score 0.67 · DAB positive pixels, combining global, sensitivity, adaptive, RGB, threshold
  2. [2] § METHODS › Image analysis ↔ src/functions.py, lines 451–529 · score 0.66 · tissue pixels, positive pixels, binary, weighted, batch, metrics

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 · 785 lines · 31 KB · no license · 2 matches

  1. #Import required libraries
  2. import cv2
  3. import pandas as pd
  4. import numpy as np
  5. from scipy import stats, ndimage
  6. import matplotlib.pyplot as plt
  7. from skimage import filters, morphology, measure, color
  8. from skimage.color import separate_stains
  9. import seaborn as sns
  10. import gc
  11. from pathlib import Path
  14. class QuPathStainVectors:
  16. #Import and use the stain vectors estimated by QuPath
  18. def __init__(self):
  19. self.hematoxylin_vector = None
  20. self.dab_vector = None
  21. self.stain_matrix = None
  22. self.all_vectors = [] # Store vectors from multiple images
  24. def add_qupath_vectors(self, h_vector, dab_vector, image_name=""):
  25. """
  26. Add stain vectors from QuPath for one image (QuPath vectors are already normalized OD vectors)
  28. Parameters:
  29. h_vector: list or array [R, G, B] for hematoxylin
  30. dab_vector: list or array [R, G, B] for DAB
  31. image_name: optional name to track which image these came from
  32. """
  33. h_vec = np.array(h_vector, dtype=np.float64)
  34. dab_vec = np.array(dab_vector, dtype=np.float64)
  36. self.all_vectors.append({
  37. 'image_name': image_name,
  38. 'hematoxylin': h_vec,
  39. 'dab': dab_vec
  40. })
  42. print(f" Added vectors from: {image_name if image_name else 'Image'}")
  43. print(f" H: [{h_vec[0]:.5f}, {h_vec[1]:.5f}, {h_vec[2]:.5f}]")
  44. print(f" DAB: [{dab_vec[0]:.5f}, {dab_vec[1]:.5f}, {dab_vec[2]:.5f}]")
  46. def calculate_average_vectors(self):
  47. """
  48. Calculate average stain vectors from all added images (representing the entire lab's staining)
  49. """
  50. if len(self.all_vectors) == 0:
  51. raise ValueError("No vectors added yet!")
  53. # Extract all H and DAB vectors
  54. h_vectors = np.array([v['hematoxylin'] for v in self.all_vectors])
  55. dab_vectors = np.array([v['dab'] for v in self.all_vectors])
  57. # Calculate mean
  58. avg_h = np.mean(h_vectors, axis=0)
  59. avg_dab = np.mean(dab_vectors, axis=0)
  61. # Calculate standard deviation (variability across images)
  62. std_h = np.std(h_vectors, axis=0)
  63. std_dab = np.std(dab_vectors, axis=0)
  65. # Store
  66. self.hematoxylin_vector = avg_h
  67. self.dab_vector = avg_dab
  68. self.stain_matrix = np.array([avg_h, avg_dab])
  70. print("\n" + "="*70)
  71. print("AVERAGED STAIN VECTORS FROM QUPATH")
  72. print("="*70)
  73. print(f"Based on {len(self.all_vectors)} images\n")
  74. print(f"Hematoxylin: [{avg_h[0]:.5f}, {avg_h[1]:.5f}, {avg_h[2]:.5f}]")
  75. print(f"DAB: [{avg_dab[0]:.5f}, {avg_dab[1]:.5f}, {avg_dab[2]:.5f}]")
  76. print(f"\nVariability (std dev):")
  77. print(f"Hematoxylin: [{std_h[0]:.5f}, {std_h[1]:.5f}, {std_h[2]:.5f}]")
  78. print(f"DAB: [{std_dab[0]:.5f}, {std_dab[1]:.5f}, {std_dab[2]:.5f}]")
  79. print("="*70)
  81. # Check if variability is acceptable
  82. max_std = max(std_h.max(), std_dab.max())
  83. if max_std < 0.05:
  84. print("Low variability - excellent consistency across images")
  85. elif max_std < 0.10:
  86. print("Moderate variability - good consistency")
  87. else:
  88. print("High variability")
  90. return self.stain_matrix
  92. def visualize_vector_consistency(self):
  93. """
  94. Visualize how consistent the vectors are across images
  95. """
  96. if len(self.all_vectors) < 2:
  97. print("Need at least 2 images to visualize consistency")
  98. return
  100. h_vectors = np.array([v['hematoxylin'] for v in self.all_vectors])
  101. dab_vectors = np.array([v['dab'] for v in self.all_vectors])
  102. names = [v['image_name'] for v in self.all_vectors]
  104. fig, axes = plt.subplots(2, 3, figsize=(15, 10))
  106. # Plot each RGB component
  107. components = ['Red', 'Green', 'Blue']
  108. colors = ['red', 'green', 'blue']
  110. for i, (comp, color) in enumerate(zip(components, colors)):
  111. # Hematoxylin
  112. ax = axes[0, i]
  113. h_vals = h_vectors[:, i]
  114. ax.scatter(range(len(h_vals)), h_vals, c=color, s=100, alpha=0.6)
  115. ax.axhline(h_vals.mean(), color='black', linestyle='--',
  116. label=f'Mean: {h_vals.mean():.4f}')
  117. ax.set_ylabel('Vector Component Value')
  118. ax.set_title(f'Hematoxylin - {comp} Component')
  119. ax.set_xticks(range(len(names)))
  120. ax.set_xticklabels(names, rotation=45, ha='right')
  121. ax.legend()
  122. ax.grid(True, alpha=0.3)
  124. # DAB
  125. ax = axes[1, i]
  126. dab_vals = dab_vectors[:, i]
  127. ax.scatter(range(len(dab_vals)), dab_vals, c=color, s=100, alpha=0.6)
  128. ax.axhline(dab_vals.mean(), color='black', linestyle='--',
  129. label=f'Mean: {dab_vals.mean():.4f}')
  130. ax.set_ylabel('Vector Component Value')
  131. ax.set_title(f'DAB - {comp} Component')
  132. ax.set_xticks(range(len(names)))
  133. ax.set_xticklabels(names, rotation=45, ha='right')
  134. ax.legend()
  135. ax.grid(True, alpha=0.3)
  137. plt.tight_layout()
  138. plt.suptitle('Stain Vector Consistency Across Images',
  139. fontsize=14, fontweight='bold', y=1.02)
  140. plt.show()
  142. def deconvolve_image(self, image):
  143. # 1.Convert to Optical Density (OD)
  144. img_float = image.astype(np.float64) / 255.0
  145. img_od = -np.log(img_float + 1e-6)
  147. # 2.Construct the 3x3 Matrix properly
  148. # We need a 3rd 'Residual' vector that is perpendicular to H and DAB
  149. h_v = self.hematoxylin_vector
  150. d_v = self.dab_vector
  151. res_v = np.cross(h_v, d_v)
  152. res_v = res_v / np.linalg.norm(res_v)
  154. stain_matrix = np.array([h_v, d_v, res_v])
  156. # 3.Matrix Inversion
  157. # This is what creates the separation instead of just a color swap.
  158. inverse_matrix = np.linalg.inv(stain_matrix)
  160. # 4.Multiply OD by the INVERSE matrix
  161. # This subtracts the 'contribution' of one stain from the other.
  162. deconvolved = img_od @ inverse_matrix
  164. # Channel 0 is H, Channel 1 is DAB
  165. h_channel = np.clip(deconvolved[:, :, 0], 0, None)
  166. dab_channel = np.clip(deconvolved[:, :, 1], 0, None)
  168. return h_channel, dab_channel
  171. def test_deconvolution(self, image_path):
  173. img = cv2.imread(image_path)
  174. img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
  176. # 1.Perform deconvolution
  177. h, dab = self.deconvolve_image(img_rgb)
  179. # 2.RECONSTRUCT RGB IMAGES
  180. # Use the Beer-Lambert law: Intensity = 255 * exp(-OD * Vector)
  181. # Add a newaxis so the 2D channel can be multiplied by the 1D [R, G, B] vector
  182. h_rgb_vis = 255 * np.exp(-h[:, :, np.newaxis] * self.hematoxylin_vector)
  183. dab_rgb_vis = 255 * np.exp(-dab[:, :, np.newaxis] * self.dab_vector)
  185. # 3. Finalize for display
  186. h_rgb_vis = np.clip(h_rgb_vis, 0, 255).astype(np.uint8)
  187. dab_rgb_vis = np.clip(dab_rgb_vis, 0, 255).astype(np.uint8)
  189. # Calculate correlation on raw OD data
  190. correlation = np.corrcoef(h.flatten(), dab.flatten())[0, 1]
  192. # Visualize
  193. fig = plt.figure(figsize=(16, 10))
  195. # Row 1: Original and RGB-reconstructed channels
  196. ax1 = plt.subplot(2, 3, 1)
  197. ax1.imshow(img_rgb)
  198. ax1.set_title('Original Image', fontsize=12, fontweight='bold')
  199. ax1.axis('off')
  201. ax2 = plt.subplot(2, 3, 2)
  202. ax2.imshow(h_rgb_vis)
  203. ax2.set_title('Hematoxylin Only\n(Nuclei Reconstructed)', fontsize=12, fontweight='bold')
  204. ax2.axis('off')
  206. ax3 = plt.subplot(2, 3, 3)
  207. ax3.imshow(dab_rgb_vis)
  208. ax3.set_title('DAB Only\n(Protein Reconstructed)', fontsize=12, fontweight='bold')
  209. ax3.axis('off')
  211. # Row 2
  212. ax4 = plt.subplot(2, 3, 4)
  213. ax4.hist(h.flatten(), bins=50, color='blue', alpha=0.7, edgecolor='black')
  214. ax4.set_xlabel('Hematoxylin Intensity (OD)')
  215. ax4.set_title('Hematoxylin Distribution')
  217. ax5 = plt.subplot(2, 3, 5)
  218. ax5.hist(dab.flatten(), bins=50, color='brown', alpha=0.7, edgecolor='black')
  219. ax5.set_xlabel('DAB Intensity (OD)')
  220. ax5.set_title('DAB Distribution')
  222. ax6 = plt.subplot(2, 3, 6)
  223. sample_indices = np.random.choice(h.size, min(10000, h.size), replace=False)
  224. ax6.scatter(h.flatten()[sample_indices], dab.flatten()[sample_indices],
  225. alpha=0.2, s=1, c='black')
  226. ax6.set_title(f'Correlation: {correlation:.3f}\n(L-shape = Excellent)')
  228. plt.tight_layout()
  229. plt.show()
  231. return h, dab
  233. def visualize_vector_consistency(self):
  234. """
  235. Visualize how consistent vectors are across images
  236. """
  237. if len(self.all_vectors) < 2:
  238. print("Need at least 2 images to visualize consistency")
  239. return
  241. h_vectors = np.array([v['hematoxylin'] for v in self.all_vectors])
  242. dab_vectors = np.array([v['dab'] for v in self.all_vectors])
  243. names = [v['image_name'] for v in self.all_vectors]
  245. fig, axes = plt.subplots(2, 3, figsize=(15, 10))
  247. components = ['Red', 'Green', 'Blue']
  248. colors = ['red', 'green', 'blue']
  250. for i, (comp, color) in enumerate(zip(components, colors)):
  251. # Hematoxylin
  252. ax = axes[0, i]
  253. h_vals = h_vectors[:, i]
  254. ax.scatter(range(len(h_vals)), h_vals, c=color, s=100, alpha=0.6)
  255. ax.axhline(h_vals.mean(), color='black', linestyle='--', linewidth=2,
  256. label=f'Mean: {h_vals.mean():.4f}')
  257. ax.set_ylabel('Vector Component', fontsize=10)
  258. ax.set_title(f'Hematoxylin - {comp}', fontsize=11, fontweight='bold')
  259. ax.set_xticks(range(len(names)))
  260. ax.set_xticklabels(names, rotation=45, ha='right', fontsize=8)
  261. ax.legend(fontsize=9)
  262. ax.grid(True, alpha=0.3)
  264. # DAB
  265. ax = axes[1, i]
  266. dab_vals = dab_vectors[:, i]
  267. ax.scatter(range(len(dab_vals)), dab_vals, c=color, s=100, alpha=0.6)
  268. ax.axhline(dab_vals.mean(), color='black', linestyle='--', linewidth=2,
  269. label=f'Mean: {dab_vals.mean():.4f}')
  270. ax.set_ylabel('Vector Component', fontsize=10)
  271. ax.set_title(f'DAB - {comp}', fontsize=11, fontweight='bold')
  272. ax.set_xticks(range(len(names)))
  273. ax.set_xticklabels(names, rotation=45, ha='right', fontsize=8)
  274. ax.legend(fontsize=9)
  275. ax.grid(True, alpha=0.3)
  277. plt.suptitle('Stain Vector Consistency Across Images',
  278. fontsize=14, fontweight='bold')
  279. plt.tight_layout()
  280. plt.show()
  282. def save_vectors(self, filename='qupath_stain_vectors.txt'):
  283. """
  284. Save averaged vectors to file
  285. """
  286. if self.stain_matrix is None:
  287. raise ValueError("Calculate average vectors first!")
  289. with open(filename, 'w') as f:
  290. f.write("# Stain Vectors from QuPath Analysis\n")
  291. f.write(f"# Averaged from {len(self.all_vectors)} images\n")
  292. f.write("# These are NORMALIZED OPTICAL DENSITY vectors\n")
  293. f.write("# Format: [R, G, B]\n\n")
  295. f.write(f"Hematoxylin: [{self.hematoxylin_vector[0]:.6f}, "
  296. f"{self.hematoxylin_vector[1]:.6f}, "
  297. f"{self.hematoxylin_vector[2]:.6f}]\n")
  298. f.write(f"DAB: [{self.dab_vector[0]:.6f}, "
  299. f"{self.dab_vector[1]:.6f}, "
  300. f"{self.dab_vector[2]:.6f}]\n")
  302. f.write("\n# Individual image vectors:\n")
  303. for v in self.all_vectors:
  304. f.write(f"\n{v['image_name']}:\n")
  305. f.write(f" H: [{v['hematoxylin'][0]:.6f}, "
  306. f"{v['hematoxylin'][1]:.6f}, "
  307. f"{v['hematoxylin'][2]:.6f}]\n")
  308. f.write(f" DAB: [{v['dab'][0]:.6f}, "
  309. f"{v['dab'][1]:.6f}, "
  310. f"{v['dab'][2]:.6f}]\n")
  312. print(f"\n✓ Vectors saved to: {filename}")
  314. def load_vectors(self, filename):
  315. """
  316. Load previously saved vectors
  317. """
  318. vectors = {}
  319. with open(filename, 'r') as f:
  320. for line in f:
  321. if line.startswith('Hematoxylin:'):
  322. vec_str = line.split('[')[1].split(']')[0]
  323. vectors['h'] = np.array([float(x) for x in vec_str.split(',')])
  324. elif line.startswith('DAB:'):
  325. vec_str = line.split('[')[1].split(']')[0]
  326. vectors['dab'] = np.array([float(x) for x in vec_str.split(',')])
  328. self.hematoxylin_vector = vectors['h']
  329. self.dab_vector = vectors['dab']
  330. self.stain_matrix = np.array([vectors['h'], vectors['dab']])
  332. print("Stain vectors loaded successfully!")
  333. print(f" H: [{self.hematoxylin_vector[0]:.5f}, {self.hematoxylin_vector[1]:.5f}, {self.hematoxylin_vector[2]:.5f}]")
  334. print(f" DAB: [{self.dab_vector[0]:.5f}, {self.dab_vector[1]:.5f}, {self.dab_vector[2]:.5f}]")
  336. return self.stain_matrix
  339. class DABQuantifier:
  340. """
  341. Optimized DAB quantification for batch processing.
  342. """
  344. def __init__(self, reference_background=None, reference_std=None):
  345. self.reference_background = reference_background
  346. self.reference_std = reference_std
  347. self.dab_vector = np.array([0.368, 0.597, 0.706])
  349. def calibrate_from_background(self, background_images, visualize=True):
  350. """Calibrate background"""
  351. all_od_values = []
  352. image_stats = []
  354. print("="*60)
  355. print("CALIBRATING BACKGROUND FROM WHITE MATTER")
  356. print("="*60)
  358. for img_path in background_images:
  359. img = cv2.imread(str(img_path))
  360. if img is None:
  361. continue
  363. img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
  364. img_od = -np.log((img_rgb.astype(np.float64) / 255.0) + 1e-6) #OD conversion
  365. dab_od = np.dot(img_od, self.dab_vector)
  367. all_od_values.extend(dab_od.flatten()[::10]) # Subsample (every 10th pixel for memory)
  369. image_stats.append({
  370. 'filename': Path(img_path).name,
  371. 'median': np.median(dab_od),
  372. 'mean': np.mean(dab_od)
  373. })
  375. print(f"{Path(img_path).name}: Median={np.median(dab_od):.4f}")
  377. if len(all_od_values) == 0:
  378. print("ERROR: No calibration images found.")
  379. return None, None
  381. all_od_values = np.array(all_od_values)
  383. # Robust statistics
  384. self.reference_background = np.median(all_od_values) #robust percentile
  385. q75 = np.percentile(all_od_values, 75)
  386. q25 = np.percentile(all_od_values, 25)
  387. self.reference_std = (q75 - q25) / 1.349
  389. print(f"\nBackground: {self.reference_background:.4f}")
  390. print(f"Robust SD: {self.reference_std:.4f}")
  392. if visualize:
  393. self._plot_calibration(all_od_values, image_stats)
  395. return self.reference_background, self.reference_std
  397. def save_calibration(self, filepath='background_calibration.npz'):
  398. """Save calibration."""
  399. np.savez(filepath,
  400. reference_background=self.reference_background,
  401. reference_std=self.reference_std)
  402. print(f"✓ Calibration saved: {filepath}")
  404. def load_calibration(self, filepath='background_calibration.npz'):
  405. """Load calibration."""
  406. data = np.load(filepath)
  407. self.reference_background = float(data['reference_background'])
  408. self.reference_std = float(data['reference_std'])
  409. print(f" Calibration loaded: {filepath}")
  410. print(f" Background: {self.reference_background:.4f}")
  411. print(f" SD: {self.reference_std:.4f}")
  413. def _plot_calibration(self, all_od_values, image_stats):
  414. """Simplified calibration visualization."""
  415. fig, axes = plt.subplots(1, 3, figsize=(15, 4))
  417. # Histogram
  418. axes[0].hist(all_od_values, bins=200, alpha=0.7, color='brown', density=True)
  419. axes[0].axvline(self.reference_background, color='red', linestyle='--',
  420. linewidth=2, label=f'Median: {self.reference_background:.4f}')
  421. axes[0].set_xlabel('DAB OD')
  422. axes[0].set_ylabel('Density')
  423. axes[0].set_title('Background Distribution')
  424. axes[0].legend()
  425. axes[0].grid(alpha=0.3)
  427. # Cumulative
  428. sorted_od = np.sort(all_od_values)
  429. cumulative = np.arange(1, len(sorted_od) + 1) / len(sorted_od) * 100
  430. axes[1].plot(sorted_od, cumulative, color='brown', linewidth=2)
  431. axes[1].axvline(self.reference_background, color='red', linestyle='--', linewidth=2)
  432. axes[1].axhline(50, color='gray', linestyle=':', alpha=0.5)
  433. axes[1].set_xlabel('DAB OD')
  434. axes[1].set_ylabel('Cumulative %')
  435. axes[1].set_title('Cumulative Distribution')
  436. axes[1].grid(alpha=0.3)
  438. # Per-image
  439. df_stats = pd.DataFrame(image_stats)
  440. axes[2].scatter(range(len(df_stats)), df_stats['median'],
  441. color='green', s=80, alpha=0.7, edgecolor='black')
  442. axes[2].axhline(self.reference_background, color='red', linestyle='--', linewidth=2)
  443. axes[2].set_xlabel('Image Index')
  444. axes[2].set_ylabel('Median DAB OD')
  445. axes[2].set_title('Per-Image Background')
  446. axes[2].grid(alpha=0.3)
  448. plt.tight_layout()
  449. plt.show()
  451. def quantify_image(self, image_path, total_tissue_pixels, threshold_method='fixed_adaptive',
  452. threshold_param=3.5):
  453. """
  454. Quantify DAB in a single image.
  456. Args:
  457. image_path: Path to image
  458. threshold_method:
  459. 'fixed' - k × background_std (param = k, default 1.5)
  460. 'fixed_adaptive' - Combines global + local stats (param = global_weight, default 1.5)
  461. 'triangle' - Triangle algorithm (param ignored)
  462. 'percentile' - Based on percentile range (param = sensitivity, default 0.3)
  463. 'multiscale' - Multi-scale combination (param = conservativeness, default 1.5)
  464. threshold_param: Parameter for threshold method
  466. Returns:
  467. Dictionary with essential metrics only
  468. """
  469. if self.reference_background is None:
  470. raise ValueError("Must calibrate background first!")
  472. try:
  473. img = cv2.imread(str(image_path))
  474. if img is None:
  475. return None
  477. #OD Conversion and DAB extraction
  478. img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
  479. img_od = -np.log((img_rgb.astype(np.float32) / 255.0) + 1e-6)
  480. dab_od = np.dot(img_od, self.dab_vector)
  482. #Background subtraction
  483. dab_signal = dab_od - self.reference_background
  484. dab_signal = np.clip(dab_signal, 0, None)
  486. # Calculate threshold
  487. threshold = self._calculate_threshold(
  488. dab_signal, threshold_method, threshold_param
  489. )
  491. # Binary mask
  492. dab_positive = (dab_signal > threshold)
  494. # Calculate metrics
  495. positive_pixels = np.sum(dab_positive)
  497. # Essential metrics only
  498. results = {
  499. 'filename': Path(image_path).name,
  501. # RAW COUNTS
  502. 'positive_pixels': int(positive_pixels),
  503. 'total_tissue_pixels': int(total_tissue_pixels),
  505. # AREA METRICS (normalized by tissue)
  506. 'area_percent': round((positive_pixels / total_tissue_pixels * 100), 3) if total_tissue_pixels > 0 else 0,
  508. # INTENSITY METRICS (positive regions only)
  509. 'mean_intensity': round(np.mean(dab_signal[dab_positive]), 4) if positive_pixels > 0 else 0,
  511. # NORMALIZED INTENSITY
  512. 'dab_density': round(np.sum(dab_signal[dab_positive])/ total_tissue_pixels, 6) if total_tissue_pixels > 0 else 0,
  514. # THRESHOLD INFO
  515. 'threshold_value': round(threshold, 4),
  516. 'threshold_method': threshold_method,
  518. # QC
  519. 'tissue_coverage_percent': round((total_tissue_pixels / dab_signal.size * 100), 2),
  520. 'max_dab_signal': round(np.max(dab_signal), 4)
  521. }
  523. # Memory cleanup for batch stability
  524. del img, img_rgb, img_od, dab_od, dab_signal
  525. return results
  527. except Exception as e:
  528. print(f"Error processing {image_path}: {str(e)}")
  529. return None
  531. def _calculate_threshold(self, dab_signal, method, param):
  532. """Calculate threshold using specified method."""
  534. if method == 'fixed':
  535. # Simple: k × SD above background
  536. threshold = param * self.reference_std
  538. elif method == 'fixed_adaptive':
  539. # Combines global background stats with local tissue stats
  540. global_thresh = param * self.reference_std
  541. local_mean = np.mean(dab_signal)
  542. local_std = np.std(dab_signal)
  544. # Only use local if tissue has reasonable signal
  545. if local_mean > 2 * self.reference_std:
  546. local_thresh = local_mean + 0.5 * local_std
  547. # Weight toward global (more stable)
  548. threshold = 0.7 * global_thresh + 0.3 * local_thresh
  549. else:
  550. threshold = global_thresh
  552. elif method == 'triangle':
  553. # Triangle algorithm - good for skewed distributions
  554. dab_norm = (dab_signal / np.max(dab_signal) * 255).astype(np.uint8)
  555. try:
  556. threshold = filters.threshold_triangle(dab_norm)
  557. threshold = (threshold / 255.0) * np.max(dab_signal)
  558. except:
  559. threshold = param * self.reference_std
  561. elif method == 'percentile':
  562. # Percentile-based: find pixels in top percentage
  563. p98 = np.percentile(dab_signal, 98)
  564. p75 = np.percentile(dab_signal, 75)
  565. # param controls sensitivity: 0.3 = moderate, 0.5 = sensitive
  566. threshold = p75 + param * (p98 - p75)
  568. elif method == 'multiscale':
  569. # Multi-scale: combines multiple threshold estimates
  570. # Good for heterogeneous staining
  572. # Method 1: Fixed
  573. t1 = param * self.reference_std
  575. # Method 2: Mean + SD
  576. t2 = np.mean(dab_signal) + np.std(dab_signal)
  578. # Method 3: Percentile
  579. t3 = np.percentile(dab_signal, 75) + 0.3 * (
  580. np.percentile(dab_signal, 98) - np.percentile(dab_signal, 75)
  581. )
  583. # Weight toward more conservative (higher) threshold
  584. threshold = np.median([t1, t2, t3])
  586. else:
  587. # Default fallback
  588. threshold = 1.5 * self.reference_std
  590. return threshold
  592. def test_thresholds(self, test_images, save_fig=True):
  593. """
  594. Test different threshold methods on representative images.
  596. Args:
  597. test_images: List of paths [pale_image, intense_image]
  598. tissue_mask_threshold: Tissue detection threshold
  599. save_fig: Save comparison figure
  600. """
  601. if self.reference_background is None:
  602. raise ValueError("Must calibrate background first!")
  604. methods_to_test = [
  605. ('fixed', 1.0, 'Fixed: 1.0σ'),
  606. ('fixed', 1.5, 'Fixed: 1.5σ'),
  607. ('fixed', 2.0, 'Fixed: 2.0σ'),
  608. ('fixed_adaptive', 3.5, 'Adaptive Fixed'),
  609. ('triangle', None, 'Triangle'),
  610. ('percentile', 0.3, 'Percentile (0.3)'),
  611. ('multiscale', 1.5, 'Multi-scale')
  612. ]
  614. results_table = []
  616. print("\n" + "="*80)
  617. print("THRESHOLD METHOD COMPARISON")
  618. print("="*80)
  620. for img_path in test_images:
  621. print(f"\nImage: {Path(img_path).name}")
  622. print("-"*80)
  623. print(f"{'Method':<20} {'Threshold':<12} {'Area %':<10} {'Mean Int':<12} {'DAB Density'}")
  624. print("-"*80)
  626. for method, param, label in methods_to_test:
  627. result = self.quantify_image(
  628. img_path,
  629. threshold_method=method,
  630. threshold_param=param if param else 1.5,
  631. )
  633. if result:
  634. print(f"{label:<20} {result['threshold_value']:<12.4f} "
  635. f"{result['area_percent']:<10.2f} "
  636. f"{result['mean_positive_intensity']:<12.4f} "
  637. f"{result['dab_density']:.6f}")
  639. results_table.append({
  640. 'image': Path(img_path).name,
  641. 'method': label,
  642. **result
  643. })
  645. # Create comparison visualization
  646. if save_fig and len(test_images) == 2:
  647. self._plot_threshold_comparison(test_images, methods_to_test, tissue_mask_threshold)
  649. return pd.DataFrame(results_table)
  651. def _plot_threshold_comparison(self, test_images, methods, tissue_threshold):
  652. """Create side-by-side comparison of threshold methods."""
  653. fig, axes = plt.subplots(len(test_images), len(methods) + 1,
  654. figsize=(4*(len(methods)+1), 5*len(test_images)))
  656. if len(test_images) == 1:
  657. axes = axes.reshape(1, -1)
  659. for row, img_path in enumerate(test_images):
  660. # Load image
  661. img = cv2.imread(str(img_path))
  662. img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
  664. # Original
  665. axes[row, 0].imshow(img_rgb)
  666. axes[row, 0].set_title(f'Original\n{Path(img_path).name}', fontsize=10)
  667. axes[row, 0].axis('off')
  669. # Each method
  670. for col, (method, param, label) in enumerate(methods, 1):
  671. result = self.quantify_image(
  672. img_path,
  673. threshold_method=method,
  674. threshold_param=param if param else 1.5,
  675. )
  677. if result:
  678. # Create overlay
  679. overlay = img_rgb.copy()
  680. # Recreate mask for visualization
  681. gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
  682. img_od = -np.log((img_rgb.astype(np.float32) / 255.0) + 1e-6)
  683. dab_od = np.dot(img_od, self.dab_vector)
  684. dab_signal = np.clip(dab_od - self.reference_background, 0, None)
  686. threshold = result['threshold_value']
  687. dab_positive = (dab_signal > threshold)
  689. overlay[dab_positive] = [255, 0, 0]
  691. axes[row, col].imshow(overlay)
  692. title = (f'{label}\nThresh: {threshold:.3f}\n'
  693. f'Area: {result["area_percent"]:.1f}%\n'
  694. f'Mean: {result["mean_positive_intensity"]:.4f}')
  695. axes[row, col].set_title(title, fontsize=9)
  696. axes[row, col].axis('off')
  698. plt.tight_layout()
  699. plt.savefig('threshold_comparison.png', dpi=200, bbox_inches='tight')
  700. plt.show()
  701. print("\n✓ Comparison saved to: threshold_comparison.png")
  703. def batch_process(self, image_folder, output_csv='results.csv',
  704. output_masks_folder=None, threshold_method='fixed_adaptive',
  705. threshold_param=1.5):
  706. """
  707. Optimized batch processing - saves only essential metrics.
  709. Args:
  710. image_folder: Folder with images
  711. output_csv: Output CSV file
  712. output_masks_folder: Optional folder to save masks
  713. threshold_method: Threshold algorithm
  714. threshold_param: Parameter for threshold
  716. Returns:
  717. DataFrame with results
  718. """
  719. image_folder = Path(image_folder)
  720. image_files = list(image_folder.glob('*.png')) + \
  721. list(image_folder.glob('*.jpg')) + \
  722. list(image_folder.glob('*.tif*'))
  724. if output_masks_folder:
  725. output_masks_folder = Path(output_masks_folder)
  726. output_masks_folder.mkdir(parents=True, exist_ok=True)
  728. results_list = []
  730. print(f"\n{'='*70}")
  731. print(f"BATCH PROCESSING: {len(image_files)} images")
  732. print(f"Method: {threshold_method}, Param: {threshold_param}")
  733. print(f"{'='*70}\n")
  735. for i, img_path in enumerate(image_files, 1):
  736. print(f"[{i}/{len(image_files)}] {img_path.name}...", end=' ')
  738. result = self.quantify_image(
  739. img_path,
  740. threshold_method=threshold_method,
  741. threshold_param=threshold_param
  742. )
  744. if result:
  745. # Save mask if requested
  746. if output_masks_folder:
  747. self._save_mask(img_path, result, output_masks_folder,
  748. threshold_param)
  750. results_list.append(result)
  751. print(f"✓ (Area: {result['area_percent']:.2f}%, DAB: {result['mean_positive_intensity']:.4f})")
  752. else:
  753. print("✗ Failed")
  755. df = pd.DataFrame(results_list)
  756. df.to_csv(output_csv, index=False)
  758. print(f"\n{'='*70}")
  759. print(f"✓ Complete! Processed: {len(results_list)}/{len(image_files)}")
  760. print(f" Results: {output_csv}")
  761. if output_masks_folder:
  762. print(f" Masks: {output_masks_folder}")
  763. print(f"{'='*70}\n")
  765. return df
  767. def _save_mask(self, img_path, result, output_folder, dab_positive, tissue_mask):
  768. """Save visualization mask for QC."""
  769. # Create the high-contrast visualization:
  770. # White = Tissue Area, Red = DAB Positive pixels
  771. mask_vis = np.zeros((*dab_positive.shape, 3), dtype=np.uint8)
  773. # Fill tissue area with white
  774. mask_vis[tissue_mask] = [255, 255, 255]
  776. # Overlay positive DAB with Red
  777. mask_vis[dab_positive] = [255, 0, 0]
  779. mask_filename = output_folder / f"{img_path.stem}_mask.png"
  780. # Convert RGB to BGR for OpenCV saving
  781. cv2.imwrite(str(mask_filename), cv2.cvtColor(mask_vis, cv2.COLOR_RGB2BGR))

functions.py at commit e747106, no license · at the source

Overview

Authors: Harry Alexopoulos1, Xanthippi P Louka1, Edoardo Rosario De Natale2, Kelly Koutroubi1, Lisa Cashmore2, Maria T Panayotacopoulou3, Ioannis P Trougakos1, Heather Wilson2, Marios Politis2,4
ORCID iDs: Harry Alexopoulos
  1. Department of Cell Biology and Biophysics, Faculty of Biology, National and Kapodistrian University of Athens, Athens, Greece
  2. Neurodegeneration Imaging Group, University of Exeter Medical School, London, UK
  3. Department of Psychiatry, Faculty of Medicine, National and Kapodistrian University of Athens, Athens, Greece
  4. Department of Neurology, Faculty of Medicine, National and Kapodistrian University of Athens, Athens, Greece
Institutions: National and Kapodistrian University of Athens (Greece); University of Exeter (United Kingdom)
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association, volume 22, issue 8, article e71745
Dates: received 26 February 2026; accepted 17 July 2026; published online 14 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/alz.71745 · PMID 42598755 · PMCID PMC13474155 · OpenAlex W7203458904
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), human (organism), Alzheimer's / dementia (population), cellular / molecular (subfield)
Methods: Statistics, fMRI & imaging
Keywords: Alzheimer's disease, amyloid‐beta, aquaporin‐4, astrocyte dysregulation, frontal cortex, glial fibrillary acidic protein, glymphatic system, tau proteins
MeSH: Alzheimer Disease*, Aquaporin 4*, Astrocytes*, Frontal Lobe*, Glial Fibrillary Acidic Protein*, Glymphatic System*, Aged, Aged, 80 and over, Amyloid beta-Peptides, Biomarkers, Female, Gray Matter, Humans, Male, tau Proteins, White Matter (* major topic)
Topic: Cerebrospinal fluid and hydrocephalus (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: City Electrical Factors Ltd
Citations: not cited yet (Europe PMC); 40 references in the paper

Abstract

INTRODUCTION: Astrocyte dysfunction is central to Alzheimer's disease (AD), yet expression patterns of astrocytic markers remain poorly defined. We measured Aquaporin‐4 (AQP4) and glial fibrillary acidic protein (GFAP) in post‐mortem frontal cortex of AD patients and controls across BrainNet Europe (BNE) stages.

METHODS: We assessed marker expression across gray and white matter with immunohistochemistry and immunofluorescence.

RESULTS: In AD, gray‐matter AQP4 area–fraction did not differ significantly overall by immunohistochemistry, while a stage‐dependent increase emerged by BNE VI in both gray and white matter. AQP4/amyloid‐β (Aβ) and AQP4/tau ratios were significantly reduced, consistent with reduced AQP4 retention relative to local proteinopathy burden. GFAP intensity was significantly decreased in both gray and white matter of AD patients, with disorganized peri‐plaque morphology in gray matter.

DISCUSSION: These findings reveal compartment‐ and stage‐specific astrocytic dysregulation in AD frontal cortex and identify local loss of AQP4 around proteinopathy. They support investigation of astrocyte/glymphatic‐related pathways as biomarkers and therapeutic targets.

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 2 matches between paragraphs and lines of code.

xanthippilouka/Human_Brain_Image_Analysis

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: e74710621c38a0c9bf289713f7dfddf0f84c9a40, 14 May 2026
Languages: Jupyter (7), Python (1)
Size: 17 files, 8 scripts
Software Heritage: not archived
Found in: “DATA AVAILABILITY STATEMENT”
Holds: environment (requirements.txt), 7 notebooks
Not found: README, license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (8 files), OpenCV (8 files), pandas (7 files), SciPy (7 files), Matplotlib (6 files), scikit-image (6 files), seaborn (3 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
8 files
At the source: github.com/xanthippilouka/Human_Brain_Image_Analysis.git

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 8 scripts, each with its path and the digest of its content;
  • 2 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 availability statement

The custom Python scripts developed and utilized for digital image analysis have been uploaded to a public GitHub repository and are available at: https://github.com/xanthippilouka/Human_Brain_Image_Analysis.git. The raw datasets analyzed during the current study are available from the corresponding author on reasonable request.

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, 9 authors, 8 keywords, 16 MeSH terms, 1 funder, 40 references.

Cite

This paper

Alexopoulos, H., Louka, X. P., De Natale, E. R., Koutroubi, K., Cashmore, L., Panayotacopoulou, M. T., Trougakos, I. P., Wilson, H., & Politis, M. (2026). Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex. Alzheimer's & dementia : the journal of the Alzheimer's Association, 22(8), e71745. https://doi.org/10.1002/alz.71745

BibTeX

@article{alexopoulos2026regional,
author = {Alexopoulos, Harry and Louka, Xanthippi P and De Natale, Edoardo Rosario and Koutroubi, Kelly and Cashmore, Lisa and Panayotacopoulou, Maria T and Trougakos, Ioannis P and Wilson, Heather and Politis, Marios},
title = {{Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex}},
journal = {Alzheimer's \& dementia : the journal of the Alzheimer's Association},
year = {2026},
month = aug,
volume = {22},
number = {8},
pages = {e71745},
publisher = {Wiley},
issn = {1552-5260},
doi = {10.1002/alz.71745},
url = {https://doi.org/10.1002/alz.71745},
pmid = {42598755},
pmcid = {PMC13474155}
}

RIS

TY - JOUR
AU - Alexopoulos, Harry
AU - Louka, Xanthippi P
AU - De Natale, Edoardo Rosario
AU - Koutroubi, Kelly
AU - Cashmore, Lisa
AU - Panayotacopoulou, Maria T
AU - Trougakos, Ioannis P
AU - Wilson, Heather
AU - Politis, Marios
TI - Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex
T2 - Alzheimer's & dementia : the journal of the Alzheimer's Association
J2 - Alzheimers Dement
PY - 2026
DA - 2026/08/01
VL - 22
IS - 8
SP - e71745
SN - 1552-5260
PB - Wiley
DO - 10.1002/alz.71745
UR - https://doi.org/10.1002/alz.71745
LA - en
ER -

CSL-JSON

{
"id": "10.1002/alz.71745",
"type": "article-journal",
"title": "Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex",
"container-title": "Alzheimer's & dementia : the journal of the Alzheimer's Association",
"author": [
{
"family": "Alexopoulos",
"given": "Harry"
},
{
"family": "Louka",
"given": "Xanthippi P"
},
{
"family": "De Natale",
"given": "Edoardo Rosario"
},
{
"family": "Koutroubi",
"given": "Kelly"
},
{
"family": "Cashmore",
"given": "Lisa"
},
{
"family": "Panayotacopoulou",
"given": "Maria T"
},
{
"family": "Trougakos",
"given": "Ioannis P"
},
{
"family": "Wilson",
"given": "Heather"
},
{
"family": "Politis",
"given": "Marios"
}
],
"container-title-short": "Alzheimers Dement",
"volume": "22",
"issue": "8",
"page": "e71745",
"DOI": "10.1002/alz.71745",
"PMID": "42598755",
"PMCID": "PMC13474155",
"ISSN": "1552-5260",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/alz.71745",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
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/awag080 [code]
Early glymphatic failure in AppNL-F knock-in mice is linked to parenchymal border macrophages loss.
Journal: Brain : a journal of neurology
In common: Alzheimer's / dementia, cellular / molecular, 6 references
[2] doi:10.1038/s41467-026-72845-3 [code]
The membrane-to-cortex distance regulates mDia1 activity to control cortical mechanics.
Journal: Nature communications
In common: OpenCV, scikit-image, seaborn, 4 other tools, histology / microscopy, cellular / molecular, 1 reference
[3] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: OpenCV, scikit-image, seaborn, 4 other tools, Alzheimer's / dementia, 1 reference
[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: OpenCV, scikit-image, seaborn, 4 other tools, histology / microscopy, cellular / molecular, 1 reference
[5] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: OpenCV, scikit-image, seaborn, 4 other tools, histology / microscopy, Alzheimer's / dementia, cellular / molecular
[6] doi:10.1126/sciadv.aeb0404 [code]
MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI.
Journal: Science advances
In common: OpenCV, pandas, SciPy, 2 other tools, 3 references
[7] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: OpenCV, scikit-image, seaborn, 4 other tools, cellular / molecular, 1 reference
[8] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: OpenCV, scikit-image, seaborn, 4 other tools, 1 reference
[9] doi:10.1038/s41593-026-02358-1 [code]
Cerebral venous blood flow regulates intracerebral pressure and brain clearance via meningeal lymphatic vessels.
Journal: Nature neuroscience
In common: scikit-image, SciPy, Matplotlib, 1 other tool, 3 references
[10] doi:10.1002/mrm.70514 [code]
Brain Clearance of Contrast Agent in Intravenous DCE-MRI Is Measurable and Cannot Be Explained by Clearance Across the BBB Alone.
Journal: Magnetic resonance in medicine
In common: seaborn, pandas, SciPy, 2 other tools, 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.