OSCR

Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration.

Code ↔ Paper

13 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 13 matches · 5 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § STAR★Methods › Method details › Synthetic data generation ↔ MATLAB code/sub-functions/createPhaseDiversityImages.m, the whole file · a weak match · score 0.87 · Gaussian noise, create phase, phase diversity images, ground truth, Zernike coefficient, Poisson
  2. [2] § STAR★Methods › Method details › Performance metrics ↔ MATLAB code/sub-functions/calculateImageQualityMetrics.m, the whole file · a weak match · score 0.72 · discrete cosine transform, image quality metrics, DCTS, zero, pixel
  3. [3] § STAR★Methods › Method details › Performance metrics ↔ MATLAB code/processPhaseDiversityImages.m, lines 1–72 · score 0.71 · square error, image quality metrics, sharpness, root, DCTS, cropping
  4. [4] § STAR★Methods › Method details › Synthetic data generation ↔ graphycs/forward_model_wf.py, the whole file · a weak match · score 0.69 · pupil plane, forward model, Zernike modes, diversity images, tetrafoil, shifting
  5. [5] § STAR★Methods › Method details › Wide-field adaptive optics system description ↔ GRAPHYCS_demo.ipynb, lines 43–91 · score 0.68 · deformable mirror, pupil plane, diameter, diversity images, camera, beam
  6. [6] § STAR★Methods › Method details › Training details and parameters ↔ graphycs/GRAPHYCS_spatially_variant_lsm.py, lines 8–43 · score 0.67 · Loss weights, affine transformation, spatially variant, motion, Fourier
  7. [7] § STAR★Methods › Method details › Aberration correction in light-sheet microscopy of larval zebrafish brain ↔ MATLAB code/processPhaseDiversityImages.m, lines 1–72 · score 0.67 · phase diversity, diversity images, Zernike coefficients, sharpness, DCTS, frame
  8. [8] § STAR★Methods › Method details › Sample-induced aberration correction in wide-field microscopy ↔ MATLAB code/sub-functions/createPhaseDiversityImages.m, the whole file · a weak match · score 0.64 · phase diversity images, Zernike coefficient, aberrated image, noise, ratio, signal
  9. [9] § Results › Spatially varying aberration sensing across the large field of view ↔ MATLAB code/sub-functions/calculateImageQualityMetrics.m, the whole file · a weak match · score 0.63 · discrete cosine transform, image quality metrics, DCTS
  10. [10] § STAR★Methods › Method details › Sample-induced aberration correction in wide-field microscopy ↔ GRAPHYCS_demo.ipynb, lines 182–283 · score 0.62 · Fourier domain, image domain, piston, aberrated image, tip, tilt
  11. [11] § STAR★Methods › Method details › Training details and parameters ↔ GRAPHYCS_demo.ipynb, lines 43–91 · score 0.59 · Loss weights, L1, Fourier, Training
  12. [12] § Results › Spatially varying aberration sensing across the large field of view ↔ graphycs/GRAPHYCS_spatially_invariant_lsm.py, lines 372–434 · score 0.56 · map visualized, phase maps, spatially invariant, component, wavefront, model
  13. [13] § Results › Spatially varying aberration sensing across the large field of view ↔ graphycs/GRAPHYCS_spatially_variant_lsm.py, lines 370–433 · score 0.51 · map visualized, phase maps, spatially variant, component, patch, model

Paper

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

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 408 lines · 14 KB · GPL-3.0 · 3 matches

  1. # %%
  2. !pip install fft-conv-pytorch
  3. !pip install scikit-image
  5. # %%
  7. import sys
  8. from pathlib import Path
  10. # Find GRAPHYCS root (folder that contains graphycs/forward_model_wf.py)
  11. start = Path.cwd()
  12. root = None
  13. for p in [start, *start.parents]:
  14. if (p / "graphycs" / "forward_model_wf.py").exists():
  15. root = p
  16. break
  18. pkg = root / "graphycs"
  19. sys.path.insert(0, str(root))
  20. sys.path.insert(0, str(pkg))
  22. # %%
  23. from datetime import datetime
  24. import os
  25. import torch
  26. import numpy as np
  27. import matplotlib.pyplot as plt
  28. from tqdm import tqdm
  29. import skimage.io as skio
  30. import torch.nn.functional as F
  31. from torch.fft import fftshift, ifftshift, ifft2, fft2
  33. # your helper modules (now in working dir)
  34. from graphycs.forward_model_wf import forward_model_wf
  35. from graphycs.utils import *
  36. from graphycs.self_calibration import *
  38. # device
  39. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  40. print("Using device:", device)
  43. # %%
  44. self_calib_param_lr = 5e-4
  45. learning_rate = 5e-3
  46. object_learning_rate = 2e-3
  47. seed = 0
  49. data_path = 'Data/Diversity_Images_Lymph.tif'
  50. zernike_coeff_path = 'Data/appliedCoeff.txt'
  53. # ─── Calibration options ────────────────────────────────────────────────────────
  54. use_self_calibration = 1 # 1 or 0
  55. use_learnable_scales = 1 # 1 or 0
  56. use_scheduler = 0 # 1 or 0
  58. # ─── Optimization hyperparameters ───────────────────────────────────────────────
  59. epochs = 500
  60. batch_size = 22
  61. use_batch_shuffling = 0 # 1 or 0
  62. use_L1_loss = 1 # 1 or 0
  63. fourier_loss_weight = 1e-5
  65. # ─── Visualization controls for training loop ───────────────────────────────────
  66. vis_frequency = 200
  67. vis_intermediates = 1 # keep in-memory stacks only
  69. # ─── Zernike orders ─────────────────────────────────────────────────────────────
  70. n_max = 14
  71. n_max_estimated = 14
  73. # ─── Optical parameters ────────────────────────────────────────────────────────
  74. NA = 0.3
  75. camera_pixel_size = 0.5343e-6
  76. wavelength = 0.513e-6
  77. n_imm = 1.33
  78. gaussian_sigma = 10.0e-3
  80. avg_background = 0.0
  81. psf_size = 101
  82. img_num_factor = 1
  84. ### Dxp: diameter of the deformable mirror in m
  85. Dxp = 10e-3
  86. pad_w, pad_h = psf_size - 1, psf_size - 1
  88. # ─── Zernike basis and defining the beam and Deformable mirror in the pupil plane────────────────────────────────────────────────────────────
  89. M = 255
  90. _, zernikes = zernike_pd_generation_higher_order(6, n_max, M, camera_pixel_size, wavelength, NA)
  91. zernikes = zernikes.to(device)
  95. # %%
  96. # ─── Setup seeds ────────────────────────────────────────────────────
  97. torch.manual_seed(seed)
  98. np.random.seed(seed)
  99. torch.cuda.manual_seed(seed)
  100. torch.backends.cudnn.deterministic = True
  101. torch.backends.cudnn.benchmark = False
  103. # %%
  104. # ─── Load applied coefficients ────────────────────────────────────────────────
  105. coeffs = np.loadtxt(zernike_coeff_path)
  106. coeffs = coeffs[::img_num_factor]
  107. coeffs = torch.tensor(coeffs, dtype=torch.float32).to(device)
  109. # coeffs[pair_idx]: known DM-applied Zernike coefficients for each diversity image.
  111. # ─── Load data ────────────────────────────────────────────────────────────────
  112. phase_added = skio.imread(data_path).astype(np.float32)
  113. bg = np.min(phase_added[phase_added > 0])
  114. phase_added = np.clip(phase_added - bg, 0, None)
  115. phase_added /= phase_added.max()
  116. phase_added = np.squeeze(phase_added)[::img_num_factor]
  117. phase_added = torch.from_numpy(phase_added).to(device)
  119. # phase_added: normalized observed diversity stack with shape [num_images, H, W].
  121. # ─── Build learnable forward model ────────────────────────────────────────────
  122. forward_model = forward_model_wf(
  123. init_object=phase_added[0].clone(),
  124. n_max=n_max,
  125. psf_size=psf_size,
  126. M=M,
  127. lmbda=wavelength,
  128. pixel_size=camera_pixel_size,
  129. n=n_imm,
  130. NA=NA,
  131. diversity_imgs_num=len(coeffs),
  132. device=device,
  133. use_affine_transform=bool(use_self_calibration),
  134. use_scales=bool(use_learnable_scales),
  135. ).to(device)
  138. # Aliases used by downstream analysis cells.
  139. found_zernike_coef = forward_model.zernike_coef
  140. found_object = forward_model.estimated_obj
  142. if use_self_calibration:
  143. print("Using affine transformation self calibration parameters in forward_model_wf")
  144. self_calib_params = [
  145. forward_model.amp_x,
  146. forward_model.amp_y,
  147. forward_model.off_x,
  148. forward_model.off_y,
  149. forward_model.rot,
  150. forward_model.grid,
  151. ]
  152. else:
  153. print("Running without affine transformation self calibration")
  154. self_calib_params = []
  156. if use_learnable_scales:
  157. print("Using learnable Zernike scaling factors in forward_model_wf")
  158. scale_factors_list = list(forward_model.scales)
  159. else:
  160. print("Running without learnable Zernike scaling factors")
  161. scale_factors_list = []
  163. optimizer_param_groups = [
  164. {'params': [found_zernike_coef], 'lr': learning_rate},
  165. {'params': [found_object], 'lr': object_learning_rate},
  166. ]
  168. if use_self_calibration:
  169. for param in self_calib_params:
  170. optimizer_param_groups.append({'params': [param], 'lr': self_calib_param_lr})
  172. if use_learnable_scales:
  173. for scale_factor in scale_factors_list:
  174. optimizer_param_groups.append({'params': [scale_factor], 'lr': self_calib_param_lr})
  176. optimizer = torch.optim.Adam(optimizer_param_groups, lr=learning_rate)
  177. if use_scheduler:
  178. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs, eta_min=0)
  179. L1_loss = torch.nn.L1Loss()
  182. # %%
  183. ## Freeze piston/tip/tilt and optional high-order modes during optimization.
  184. mask = torch.ones_like(found_zernike_coef, device=device)
  185. mask[:3] = 0
  186. if n_max_estimated < len(mask):
  187. mask[n_max_estimated + 1:] = 0
  189. train_loss_curve = []
  190. image_loss_curve = []
  191. fourier_loss_curve = []
  193. found_object_stack = []
  194. iPSF_stack = []
  195. amplitudes_stack = []
  196. generated_imgs = []
  198. mse_loss = torch.nn.MSELoss()
  199. do_vis = vis_frequency > 0
  201. t = tqdm(range(epochs))
  202. for epoch_idx in t:
  203. if use_batch_shuffling == 1:
  204. idxs = torch.randperm(len(coeffs)).long().to(device)
  205. else:
  206. idxs = torch.arange(len(coeffs)).long().to(device)
  208. forward_model.estimated_obj.requires_grad_()
  209. forward_model.zernike_coef.requires_grad_()
  211. epoch_train_loss = 0.0
  212. epoch_image_loss = 0.0
  213. epoch_fourier_loss = 0.0
  215. for it in range(0, len(coeffs), batch_size):
  216. idx = idxs[it:min(it + batch_size, len(coeffs))]
  217. coeff_batch, y_batch = coeffs[idx], phase_added[idx]
  219. optimizer.zero_grad()
  220. aberrated_imgs, psfs, amplitude_transformed = forward_model(coeff_batch, idx)
  222. recon_observed_imgs_FT = torch.real(torch.fft.fft2(aberrated_imgs, dim=(-2, -1)))
  223. observed_imgs_FT = torch.real(torch.fft.fft2(y_batch, dim=(-2, -1)))
  225. if use_L1_loss == 1:
  226. Fourier_loss = L1_loss(recon_observed_imgs_FT.squeeze(), observed_imgs_FT.squeeze())
  227. recon_loss = L1_loss(aberrated_imgs.squeeze(), y_batch.squeeze())
  228. else:
  229. Fourier_loss = mse_loss(recon_observed_imgs_FT.squeeze(), observed_imgs_FT.squeeze())
  230. recon_loss = mse_loss(aberrated_imgs.squeeze(), y_batch.squeeze())
  232. epoch_image_loss += recon_loss.item()
  233. epoch_fourier_loss += Fourier_loss.item()
  234. loss = recon_loss + fourier_loss_weight * Fourier_loss
  235. epoch_train_loss += loss.item()
  237. if do_vis and (epoch_idx % vis_frequency) == 0 and it == 0:
  238. psfs_squeezed = psfs.squeeze().detach().cpu().numpy()
  240. if vis_intermediates == 1:
  241. model_outputs_squeezed = aberrated_imgs.squeeze().detach().cpu().numpy()
  242. if model_outputs_squeezed.ndim == 3:
  243. generated_imgs.append(model_outputs_squeezed[-1, :, :])
  244. elif model_outputs_squeezed.ndim == 2:
  245. generated_imgs.append(model_outputs_squeezed)
  247. found_object_stack.append(forward_model.estimated_obj.detach().cpu().numpy())
  249. if psfs_squeezed.ndim == 3:
  250. iPSF_stack.append(psfs_squeezed[-1, :, :])
  251. elif psfs_squeezed.ndim == 2:
  252. iPSF_stack.append(psfs_squeezed)
  254. amplitudes_stack.append(amplitude_transformed.detach().cpu().numpy())
  256. loss.backward()
  258. if forward_model.zernike_coef.grad is not None:
  259. forward_model.zernike_coef.grad.mul_(mask)
  261. optimizer.step()
  263. if use_scheduler:
  264. scheduler.step()
  266. with torch.no_grad():
  267. forward_model.estimated_obj.data.clamp_(min=0.0)
  268. if use_learnable_scales:
  269. for p in forward_model.scales:
  270. p.data.clamp_(min=-1.0)
  272. train_loss_curve.append(epoch_train_loss)
  273. image_loss_curve.append(epoch_image_loss)
  274. fourier_loss_curve.append(epoch_fourier_loss)
  276. t.set_description(
  277. f"Epoch {epoch_idx + 1}/{epochs}, Total loss: {epoch_train_loss:.4f}, Image domain loss: {epoch_image_loss:.4f}, Fourier domain loss: {epoch_fourier_loss:.4f}"
  278. )
  280. # Keep explicit final handles to the trained model parameters for downstream cells.
  281. trained_model = forward_model
  282. final_found_object = trained_model.estimated_obj.detach()
  283. final_found_zernike_coef = trained_model.zernike_coef.detach()
  286. # %%
  288. # Base results path
  289. base_results = "Results"
  291. # Create a timestamp string, e.g. "20250429_163045"
  292. ts = datetime.now().strftime("%Y%m%d_%H")
  294. # Full path for this run
  295. results_dir = os.path.join(base_results, ts)
  296. os.makedirs(results_dir, exist_ok=True)
  298. # Read final trained parameters directly from the trained model.
  299. if 'trained_model' not in globals():
  300. trained_model = forward_model
  301. final_found_zernike_coef = trained_model.zernike_coef.detach()
  302. final_found_object = trained_model.estimated_obj.detach()
  304. zernike_coeffs_np = final_found_zernike_coef.cpu().numpy()
  305. found_obj_np = final_found_object.cpu().numpy()
  307. # Save Zernike coefficients
  308. np.savetxt(os.path.join(results_dir, "found_zernike_coefficients.txt"),
  309. zernike_coeffs_np, fmt="%.6e")
  311. # Save reconstructed object
  312. skio.imsave(os.path.join(results_dir, "estimated_object.tif"), found_obj_np)
  314. # Save loss curves collected in training loop
  315. np.save(os.path.join(results_dir, "train_loss_curve.npy"), np.array(train_loss_curve))
  316. np.save(os.path.join(results_dir, "image_loss_curve.npy"), np.array(image_loss_curve))
  317. np.save(os.path.join(results_dir, "fourier_loss_curve.npy"), np.array(fourier_loss_curve))
  320. # %%
  321. # — Plot training loss curves —
  322. plt.figure(figsize=(10, 4))
  324. plt.subplot(1, 3, 1)
  325. plt.plot(train_loss_curve, lw=2)
  326. plt.xlabel('Epoch')
  327. plt.ylabel('Loss')
  328. plt.title('Total Loss')
  329. plt.grid(True)
  331. plt.subplot(1, 3, 2)
  332. plt.plot(image_loss_curve, lw=2)
  333. plt.xlabel('Epoch')
  334. plt.ylabel('Loss')
  335. plt.title('Image Loss')
  336. plt.grid(True)
  338. plt.subplot(1, 3, 3)
  339. plt.plot(fourier_loss_curve, lw=2)
  340. plt.xlabel('Epoch')
  341. plt.ylabel('Loss')
  342. plt.title('Fourier Loss')
  343. plt.grid(True)
  345. plt.tight_layout()
  346. plt.show()
  349. # %%
  350. # — Compute & show estimated phase map from the trained model —
  351. if 'trained_model' not in globals():
  352. trained_model = forward_model
  353. final_found_zernike_coef = trained_model.zernike_coef.detach()
  355. estimated_phase = torch.einsum('i,ijk->jk', 1e-6 * final_found_zernike_coef, zernikes)
  356. est_phase_np = estimated_phase.detach().cpu().numpy()
  357. est_phase_np = (2 * n_imm * np.pi / wavelength) * est_phase_np # Convert from meters to radians
  359. plt.figure(figsize=(5,4))
  360. plt.imshow(est_phase_np, cmap='jet', vmin=-np.pi, vmax=np.pi)
  361. plt.colorbar(shrink=0.6)
  362. plt.title('Estimated Phase [radians]')
  363. plt.axis('off')
  364. plt.show()
  367. # %%
  368. # — Bar chart of learned Zernike coefficients from the trained model —
  369. if 'trained_model' not in globals():
  370. trained_model = forward_model
  371. coeffs_np = trained_model.zernike_coef.detach().cpu().numpy()
  372. modes = np.arange(len(coeffs_np))
  374. plt.figure(figsize=(5,3))
  375. plt.bar(modes, coeffs_np, color='C1')
  376. plt.xlabel('Zernike Mode Index')
  377. plt.ylabel('Coefficient [µm]')
  378. plt.title('Estimated Zernike Coefficients')
  379. plt.show()
  382. # %%
  383. ## Estimated zernike coefficients:
  384. print(coeffs_np)
  386. # %%
  387. # Display original vs. trained-model estimated object side-by-side
  388. if 'trained_model' not in globals():
  389. trained_model = forward_model
  390. orig_np = phase_added[0].detach().cpu().numpy()
  391. orig_np = (orig_np - orig_np.min()) / (orig_np.max() - orig_np.min()) # Normalize to [0, 1]
  392. est_obj_np = trained_model.estimated_obj.detach().cpu().numpy()
  393. est_min = est_obj_np.min()
  394. est_p999 = np.percentile(est_obj_np, 99.9)
  395. est_obj_np = np.clip((est_obj_np - est_min) / max(est_p999 - est_min, 1e-12), 0, 1) # Min->0, 99.9th percentile->1
  397. fig, axs = plt.subplots(1, 2, figsize=(10,5))
  398. axs[0].imshow(orig_np, cmap='gray', vmin=0, vmax=1)
  399. axs[0].set_title('Original Image')
  400. axs[0].axis('off')
  402. axs[1].imshow(est_obj_np, cmap='gray', vmin=0, vmax=0.8)
  403. axs[1].set_title('Estimated Object')
  404. axs[1].axis('off')
  406. plt.tight_layout()
  407. plt.show()

GRAPHYCS_demo.ipynb at commit 84c2c58, under GPL-3.0 · at the source

Overview

Authors: Eun-Seo Cho1, Joon Park1, Hyungwon Jin2, Yoonjae Chung1, Minho Eom1, Hyejin Shin3, Jae-Byum Chang3, Jung-Hoon Park2, Young-Gyu Yoon1,4,5
ORCID iDs: Young-Gyu Yoon
  1. School of Electrical Engineering, KAIST, Daejeon, Republic of Korea
  2. Department of Biomedical Engineering, Ulsan National Institute of Science and Technology (UNIST), Ulsan, Republic of Korea
  3. Department of Materials Science and Engineering, KAIST, Daejeon, Republic of Korea
  4. Department of Semiconductor System Engineering, KAIST, Daejeon, Republic of Korea
  5. KAIST Institute for Human Augmentation Convergence, Daejeon, Republic of Korea
Institutions: Korea Advanced Institute of Science and Technology (South Korea); Ulsan National Institute of Science and Technology (South Korea)
Journal: iScience, volume 29, issue 8, article 116769
Dates: received 18 November 2025; accepted 26 June 2026; published online 14 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.isci.2026.116769 · PMID 42519053 · PMCID PMC13382438 · OpenAlex W7168241314
Open access: gold, a free copy (OpenAlex)
Status: code verified
Methods: Connectivity, fMRI & imaging, Single-unit activity, calcium imaging, Physiology & signal measures
Keywords: adaptive optics, graph-based modeling, phase diversity, wavefront sensing
Topic: Neural Networks and Reservoir Computing (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Korea Ministry of Science and ICT (RS-2021-NR056586, RS-2022-NR068424, RS-2026-25504129, RS-2023-00264980, RS-2023-00264409, RS-2026-25475246, RS-2023-00209473, RS-2024-00401676); Human Frontier Science Program; International Human Frontier Science Program Organization (RGP003/2024); National Research Foundation of Korea; Convergence; Korea Basic Science Institute; Ministry of Education; KAIST
Citations: not cited yet (Europe PMC); 50 references in the paper

Abstract

Sensor less adaptive optics offers significant advantages over hardware-based wavefront sensing but faces persistent challenges: Its performance degrades when idealized models fail to capture system imperfections, it is largely restricted to spatially invariant aberrations, and it cannot accommodate dynamic biological samples due to static-object assumptions. Here we present graph-modeling and phase-diversity-based computational adaptive optics with self-calibration (GRAPHYCS), a differentiable graph-based modeling framework that addresses all three limitations. GRAPHYCS automatically self-calibrates to correct system-specific non-idealities, enables spatially variant wavefront sensing across extended fields of view by modeling local aberrations, and supports dynamic live-sample imaging where conventional computational methods fail. In simulations, GRAPHYCS achieves up to a 9-fold improvement in wavefront sensing accuracy compared to analytic phase diversity under system non-idealities. In real microscopy experiments, it consistently outperforms phase-diversity-based methods compared in this study. Furthermore, in live zebrafish brain imaging, GRAPHYCS enables simultaneous wavefront sensing and neuronal activity detection—an application beyond the reach of existing approaches without additional hardware complexity.

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

NICALab/GRAPHYCS

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 84c2c588030f909abf4c6da899f65f40afb49a9f, 23 July 2026
Languages: Python (11), Jupyter (1)
Size: 17 files, 12 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, environment (requirements.txt), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (12 files), PyTorch (12 files), scikit-image (7 files), Matplotlib (6 files), SciPy (5 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
14 files
At the source: github.com/NICALab/GRAPHYCS

ceej640/PhaseDiversity

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: b0839b690fd965a9d5628b1ba45a3bfadeae80f0, 25 February 2025
Languages: MATLAB (29)
Size: 31 files, 29 scripts
Software Heritage: not archived
Found in: the text, “Comparison with other algorithms”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Parallel Computing Toolbox (3 files), Curve Fitting Toolbox (1 file), Image Processing Toolbox (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
30 files
At the source: github.com/ceej640/PhaseDiversity

Intelligent-Sensing/NeuWS

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c56b9bb8f3c722b4288af73a27e2507129a01de0, 30 June 2023
Languages: Python (4)
Size: 7 files, 4 scripts
Software Heritage: not archived
Found in: the text, “Comparison with other algorithms”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), PyTorch (4 files), SciPy (3 files), imageio (2 files), Matplotlib (2 files), h5py (1 file), Pillow (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/Intelligent-Sensing/NeuWS

NICALab/SUPPORT

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9fba0f415b35106d7d7b9c0144e72917329f0575, 11 August 2025
Languages: Python (13)
Size: 33 files, 13 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README, license file, environment (env.yml), documentation
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (12 files), PyTorch (12 files), scikit-image (8 files), Matplotlib (2 files), Pillow (2 files), tifffile (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
15 files
At the source: github.com/NICALab/SUPPORT

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:

  • 4 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 58 scripts, each with its path and the digest of its content;
  • 13 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

Datasets cited

Data and code availability

The datasets generated and/or analyzed during the current study have been deposited at Zenodo at https://zenodo.org/records/17049780 (https://zenodo.org/records/15421484) and are publicly available as of the date of publication.

All original code has been deposited at a GitHub repository and is publicly available at https://github.com/NICALab/GRAPHYCS as of the date of publication.

Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon 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, 4 keywords, 8 funders, 50 references.

Cite

This paper

Cho, E.-S., Park, J., Jin, H., Chung, Y., Eom, M., Shin, H., Chang, J.-B., Park, J.-H., & Yoon, Y.-G. (2026). Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration. iScience, 29(8), 116769. https://doi.org/10.1016/j.isci.2026.116769

BibTeX

@article{cho2026graph,
author = {Cho, Eun-Seo and Park, Joon and Jin, Hyungwon and Chung, Yoonjae and Eom, Minho and Shin, Hyejin and Chang, Jae-Byum and Park, Jung-Hoon and Yoon, Young-Gyu},
title = {{Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration}},
journal = {iScience},
year = {2026},
month = jul,
volume = {29},
number = {8},
pages = {116769},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.116769},
url = {https://doi.org/10.1016/j.isci.2026.116769},
pmid = {42519053},
pmcid = {PMC13382438}
}

RIS

TY - JOUR
AU - Cho, Eun-Seo
AU - Park, Joon
AU - Jin, Hyungwon
AU - Chung, Yoonjae
AU - Eom, Minho
AU - Shin, Hyejin
AU - Chang, Jae-Byum
AU - Park, Jung-Hoon
AU - Yoon, Young-Gyu
TI - Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/07/14
VL - 29
IS - 8
SP - 116769
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.116769
UR - https://doi.org/10.1016/j.isci.2026.116769
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.116769",
"type": "article-journal",
"title": "Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration",
"container-title": "iScience",
"author": [
{
"family": "Cho",
"given": "Eun-Seo"
},
{
"family": "Park",
"given": "Joon"
},
{
"family": "Jin",
"given": "Hyungwon"
},
{
"family": "Chung",
"given": "Yoonjae"
},
{
"family": "Eom",
"given": "Minho"
},
{
"family": "Shin",
"given": "Hyejin"
},
{
"family": "Chang",
"given": "Jae-Byum"
},
{
"family": "Park",
"given": "Jung-Hoon"
},
{
"family": "Yoon",
"given": "Young-Gyu"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "8",
"page": "116769",
"DOI": "10.1016/j.isci.2026.116769",
"PMID": "42519053",
"PMCID": "PMC13382438",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.116769",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
14
]
]
}
}

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/s41467-026-73389-2 [code]
Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue.
Journal: Nature communications
In common: SciPy, Matplotlib, NumPy, 18 references
[2] doi:10.1038/s41467-026-75347-4 [code]
Sleep reveals dynamics integrating and segregating movement and stimulus representations in V1.
Journal: Nature communications
In common: Curve Fitting Toolbox, imageio, Parallel Computing Toolbox, 7 other tools
[3] doi:10.1038/s41467-026-73045-9 [code]
Aberration-aware 3D localization microscopy via self-supervised neural-physics learning.
Journal: Nature communications
In common: imageio, tifffile, scikit-image, 5 other tools, 2 references
[4] doi:10.1038/s41592-026-03179-7 [code]
Voltage imaging of neurons distributed across entire brains of larval zebrafish.
Journal: Nature methods
In common: scikit-image, h5py, SciPy, 2 other tools, 5 references
[5] doi:10.1038/s41467-026-76242-8 [code]
Whole-brain, all-optical interrogation of neuronal dynamics underlying gut and vascular interoception in zebrafish.
Journal: Nature communications
In common: tifffile, Parallel Computing Toolbox, scikit-image, 5 other tools, 2 references
[6] doi:10.1038/s41592-026-03066-1 [code]
A multimodal adaptive optical microscope for in vivo imaging from molecules to organisms.
Journal: Nature methods
In common: Parallel Computing Toolbox, Image Processing Toolbox, NumPy, 5 references
[7] doi:10.1126/sciadv.aee9298 [code]
Synaptic zinc plasticity shapes adaptive and maladaptive cortical plasticity following cochlear injury.
Journal: Science advances
In common: imageio, tifffile, Parallel Computing Toolbox, 6 other tools
[8] doi:10.1080/07853890.2026.2685416 [code]
Pulmonary and cerebral damage in COVID-19 survivors: is there any association?
Journal: Annals of medicine
In common: Curve Fitting Toolbox, imageio, scikit-image, 6 other tools
[9] doi:10.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: imageio, tifffile, scikit-image, 6 other tools
[10] 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: imageio, tifffile, scikit-image, 6 other 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.