OSCR

Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue.

Code ↔ Paper

4 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 4 matches
  1. [1] § Results › Fast and structure-independent aberration estimation via multi-encoder networks ↔ utils/zernike.py, lines 130–238 · score 0.90 · horizontal coma, vertical trefoil, oblique trefoil, vertical coma, vertical astigmatism, oblique astigmatism
  2. [2] § Methods › MeNet architecture and network training ↔ model/model.py, lines 63–126 · score 0.69 · PReLU, batch normalization, single encoder, kernel, blocks, activation
  3. [3] § Methods › MeNet-AO and DWS-AO correction › MeNet-AO ↔ utils/zernike.py, lines 130–238 · score 0.69 · vertical astigmatism, oblique astigmatism, primary spherical, Zernike
  4. [4] § Methods › MeNet architecture and network training ↔ .history/model/MultiEncoder_20250913205642.py, lines 12–92 · score 0.68 · PReLU, batch normalization, multi encoder, kernel, blocks, 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

Python · 310 lines · 12 KB · MIT · 2 matches

  1. import numpy as np
  2. from scipy.special import binom
  3. from csbdeep.utils import _raise
  4. from functools import lru_cache
  7. """
  8. Part of this file is adapted from:
  9. Project: phasenet
  10. Author: DEBAYAN SAHA, UWE SCHMIDT,
  11. URL: https://github.com/mpicbg-csbd/phasenet
  13. """
  16. def nm_to_noll(n, m):
  17. j = (n*(n+1))//2 + abs(m)
  18. if m> 0 and n%4 in (0,1): return j
  19. if m< 0 and n%4 in (2,3): return j
  20. if m>=0 and n%4 in (2,3): return j+1
  21. if m<=0 and n%4 in (0,1): return j+1
  22. assert False
  25. def nm_to_ansi(n, m):
  26. return (n*(n+2) + m) // 2
  29. def nm_normalization(n, m):
  30. """the norm of the zernike mode n,m in born/wolf convetion
  32. i.e. sqrt( \int | z_nm |^2 )
  33. """
  34. return np.sqrt((1.+(m==0))/(2.*n+2))
  37. def nm_polynomial(n, m, rho, theta, normed=True):
  38. """returns the zernike polyonimal by classical n,m enumeration
  40. if normed=True, then they form an orthonormal system
  42. \int z_nm z_n'm' = delta_nn' delta_mm'
  44. and the first modes are
  46. z_nm(0,0) = 1/sqrt(pi)*
  47. z_nm(1,-1) = 1/sqrt(pi)* 2r cos(phi)
  48. z_nm(1,1) = 1/sqrt(pi)* 2r sin(phi)
  49. z_nm(2,0) = 1/sqrt(pi)* sqrt(3)(2 r^2 - 1)
  50. ...
  51. z_nm(4,0) = 1/sqrt(pi)* sqrt(5)(6 r^4 - 6 r^2 +1)
  52. ...
  54. if normed =False, then they follow the Born/Wolf convention
  55. (i.e. min/max is always -1/1)
  57. \int z_nm z_n'm' = (1.+(m==0))/(2*n+2) delta_nn' delta_mm'
  59. z_nm(0,0) = 1
  60. z_nm(1,-1) = r cos(phi)
  61. z_nm(1,1) = r sin(phi)
  62. z_nm(2,0) = (2 r^2 - 1)
  63. ...
  64. z_nm(4,0) = (6 r^4 - 6 r^2 +1)
  67. """
  68. if abs(m) > n:
  69. raise ValueError(" |m| <= n ! ( %s <= %s)" % (m, n))
  71. if (n - m) % 2 == 1:
  72. return 0 * rho + 0 * theta
  74. radial = 0
  75. m0 = abs(m)
  77. for k in range((n - m0) // 2 + 1):
  78. radial += (-1.) ** k * binom(n - k, k) * binom(n - 2 * k, (n - m0) // 2 - k) * rho ** (n - 2 * k)
  80. radial *= (rho <= 1.)
  82. if normed:
  83. prefac = 1. / nm_normalization(n, m)
  84. else:
  85. prefac = 1.
  86. if m >= 0:
  87. return prefac * radial * np.cos(m0 * theta)
  88. else:
  89. return prefac * radial * np.sin(m0 * theta)
  92. @lru_cache(maxsize=32)
  93. def rho_theta(size):
  94. r = np.linspace(-1,1,size)
  95. X,Y = np.meshgrid(r,r, indexing='ij')
  96. rho = np.hypot(X,Y)
  97. theta = np.arctan2(Y,X)
  98. return rho, theta
  101. @lru_cache(maxsize=32)
  102. def outside_mask(size):
  103. rho, theta = rho_theta(size)
  104. return nm_polynomial(0, 0, rho, theta, normed=False) < 1
  107. def dict_to_list(kv):
  108. max_key = max(kv.keys())
  109. out = [0]*(max_key+1)
  110. for k,v in kv.items():
  111. out[k] = v
  112. return out
  115. def ensure_dict(values, order):
  116. if isinstance(values,dict):
  117. return values
  118. if isinstance(values,np.ndarray):
  119. values = tuple(values.ravel())
  120. if isinstance(values,(tuple,list)):
  121. order = str(order).lower()
  122. order in ('noll','ansi') or _raise(ValueError("Could not identify the Zernike nomenclature/order"))
  123. offset = 1 if order=='noll' else 0
  124. indices = range(offset,offset+len(values))
  125. return dict(zip(indices,values))
  126. raise ValueError("Could not identify the data type for dictionary formation")
  130. class Zernike:
  132. """
  133. Encapsulates Zernike polynomials
  135. :param index: string, integer or tuple, index of Zernike polynomial e.g. 'defocus', 4, (2,2)
  136. :param oder: string, defines the Zernike nomenclature if index is an integer, eg noll or ansi, default is noll
  137. """
  139. _ansi_names = ['piston', 'tilt', 'tip', 'oblique astigmatism', 'defocus',
  140. 'vertical astigmatism', 'vertical trefoil', 'vertical coma',
  141. 'horizontal coma', 'oblique trefoil', 'oblique quadrafoil',
  142. 'oblique secondary astigmatism', 'primary spherical',
  143. 'vertical secondary astigmatism', 'vertical quadrafoil']
  144. _nm_pairs = set((n,m) for n in range(200) for m in range(-n,n+1,2))
  145. _noll_to_nm = dict(zip((nm_to_noll(*nm) for nm in _nm_pairs),_nm_pairs))
  146. _ansi_to_nm = dict(zip((nm_to_ansi(*nm) for nm in _nm_pairs),_nm_pairs))
  148. def __init__(self, index, order='noll'):
  149. super().__setattr__('_mutable', True)
  150. if isinstance(index,str):
  151. if index.isdigit():
  152. index = int(index)
  153. else:
  154. name = index.lower()
  155. name in self._ansi_names or _raise(ValueError("Your input for index is string : Could not identify the name of Zernike polynomial"))
  156. index = self._ansi_names.index(name)
  157. order = 'ansi'
  159. if isinstance(index,(list,tuple)) and len(index)==2:
  160. self.n, self.m = int(index[0]), int(index[1])
  161. (self.n, self.m) in self._nm_pairs or _raise(ValueError("Your input for index is list/tuple : Could not identify the n,m order of Zernike polynomial"))
  162. elif isinstance(index,int):
  163. order = str(order).lower()
  164. order in ('noll','ansi') or _raise(ValueError("Your input for index is int : Could not identify the Zernike nomenclature/order"))
  165. if order == 'noll':
  166. index in self._noll_to_nm or _raise(ValueError("Your input for index is int and input for Zernike nomenclature is Noll: Could not identify the Zernike polynomial with this index"))
  167. self.n, self.m = self._noll_to_nm[index]
  168. elif order == 'ansi':
  169. index in self._ansi_to_nm or _raise(ValueError("Your input for index is int and input for Zernike nomenclature is ANSI: Could not identify the Zernike polynomial with this index"))
  170. self.n, self.m = self._ansi_to_nm[index]
  171. else:
  172. raise ValueError("Could not identify your index input, we accept strings, lists and tuples only")
  174. self.index_noll = nm_to_noll(self.n, self.m)
  175. self.index_ansi = nm_to_ansi(self.n, self.m)
  176. self.name = self._ansi_names[self.index_ansi] if self.index_ansi < len(self._ansi_names) else None
  177. self._mutable = False
  180. def polynomial(self, size, normed=True, outside=np.nan):
  182. """
  183. For visualization of Zernike polynomial on a disc of unit radius
  185. :param size: integer, Defines the shape of square grid, e.g. 256 or 512
  186. :param normed: boolen, Whether the Zernike polynomials are normalized, default is True
  187. :param outside: scalar, Outside padding of the spherical disc defined within a square grid, default is np.nan
  188. :return: 2D array, Zernike polynomial computed on a disc of unit radius defined within a square grid
  189. """
  191. np.isscalar(size) and int(size) > 0 or _raise(ValueError())
  192. return self.phase(*rho_theta(int(size)), normed=normed, outside=outside)
  195. def phase(self, rho, theta, normed=True, outside=None):
  197. """
  198. For creation of a Zernike polynomial with a given polar co-ordinate system
  200. :param rho: 2D square array, radial axis
  201. :param theta: 2D square array, azimuthal axis
  202. :param normed: boolen, whether the Zernike polynomials are normalized, default is True
  203. :param outside: scalar, outside padding of the spherical disc defined within a square grid, default is None
  204. :return: 2D array, Zernike polynomial computed for rho and theta
  205. """
  206. (isinstance(rho,np.ndarray) and rho.ndim==2 and rho.shape[0]==rho.shape[1]) or _raise(ValueError('Only 2D square array for radial co-ordinate is accepted'))
  207. (isinstance(theta,np.ndarray) and theta.shape==rho.shape) or _raise(ValueError('Only 2D square array for azimutha co-ordinate is accepted'))
  208. size = rho.shape[0]
  209. np.isscalar(normed) or _raise(ValueError())
  210. outside is None or np.isscalar(outside) or _raise(ValueError("Only scalar constant value for outside is accepted"))
  211. w = nm_polynomial(self.n, self.m, rho, theta, normed=bool(normed))
  212. if outside is not None:
  213. w[nm_polynomial(0, 0, rho, theta, normed=False) < 1] = outside
  215. return w
  218. def __hash__(self):
  219. return hash((self.n,self.m))
  222. def __eq__(self, other):
  223. return isinstance(other,Zernike) and (self.n,self.m) == (other.n,other.m)
  226. def __lt__(self, other):
  227. # return self.index_ansi < other.index_ansi
  228. return self.index_noll < other.index_noll
  230. def __setattr__(self, *args):
  231. if self._mutable:
  232. super().__setattr__(*args)
  233. else:
  234. raise AttributeError('Zernike is immutable')
  237. def __repr__(self):
  238. return f'Zernike(n={self.n}, m={self.m: 1}, noll={self.index_noll:2}, ansi={self.index_ansi:2}' + (f", name='{self.name}')" if self.name is not None else ")")
  242. class ZernikeWavefront:
  244. """
  245. Encapsulates the wavefront defined by Zernike polynomials
  247. :param amplitudes: dictionary, nd array, tuple or list, Amplitudes of Zernike polynomials
  248. :param oder: string, Zernike nomenclature, eg noll or ansi, default is noll
  249. """
  250. def __init__(self, amplitudes, order='noll'):
  251. amplitudes = ensure_dict(amplitudes, order)
  252. all(np.isscalar(a) for a in amplitudes.values()) or _raise(ValueError("Could not identify scalar value for amplitudes after making a dictionary"))
  254. self.zernikes = {Zernike(j,order=order):a for j,a in amplitudes.items()}
  255. self.amplitudes_noll = tuple(dict_to_list({z.index_noll:a for z,a in self.zernikes.items()})[1:])
  256. self.amplitudes_ansi = tuple(dict_to_list({z.index_ansi:a for z,a in self.zernikes.items()}))
  257. self.amplitudes_requested = tuple(self.zernikes[k] for k in sorted(self.zernikes.keys()))
  260. def __len__(self):
  261. return len(self.zernikes)
  264. def polynomial(self, size, normed=True, outside=np.nan):
  266. """
  267. For visualization of weighted sum of Zernike polynomials on a disc of unit radius
  269. :param size: integer, Defines the shape of square grid, e.g. 256 or 512
  270. :param normed: boolen, Whether the Zernike polynomials are normalized, default is True
  271. :param outside: scalar, Outside padding of the spherical disc defined within a square grid, default is np.nan
  272. :return: 2D array, weighted sums of Zernike polynomials computed on a disc of unit radius defined within a square grid
  273. """
  274. return np.sum([a * z.polynomial(size=size, normed=normed, outside=outside) for z,a in self.zernikes.items()], axis=0)
  277. def phase(self, rho, theta, normed=True, outside=None):
  279. """
  280. For creation of phase defined as a weighted sum of Zernike polynomial with a given polar co-ordinate system
  282. :param rho: 2D square array, radial axis
  283. :param theta: 2D square array, azimuthal axis
  284. :param normed: boolen, whether the Zernike polynomials are normalized, default is True
  285. :param outside: scalar, outside padding of the spherical disc defined within a square grid, default is none
  286. :return: 2D array, wavefront computed for rho and theta
  287. """
  288. return np.sum([a * z.phase(rho=rho, theta=theta, normed=normed, outside=outside) for z,a in self.zernikes.items()], axis=0)
  292. def random_zernike_wavefront(amplitude_ranges, order='noll', rng=None):
  294. """
  295. Creates random Zernike wavefront with random amplitudes drawn from a uniform distibution
  297. :param aplitude_ranges: dictionary, nd array, tuple or list, amplitude bounds
  298. :param oder: string, to define the Zernike nomenclature if index is an integer, eg noll or ansi, default is noll
  299. :param rng:
  300. :return: Zernike wavefront object
  301. """
  302. if rng is None:
  303. rng = np.random
  304. amplitude_ranges = ensure_dict(amplitude_ranges, order)
  305. all((np.isscalar(v) and v>=0) or (isinstance(v,(tuple,list)) and len(v)==2) for v in amplitude_ranges.values()) or _raise(ValueError())
  306. amplitude_ranges = {k:((-v,v) if np.isscalar(v) else v) for k,v in amplitude_ranges.items()}
  307. all(v[0]<=v[1] for v in amplitude_ranges.values()) or _raise(ValueError("Lower bound is expected to be less than the upper bound"))
  308. # return ZernikeWavefront({k:rng.uniform(*v) for k,v in amplitude_ranges.items()}, order=order)
  309. # return ZernikeWavefront({k: rng.normal(loc=0, scale=(v[1] - v[0]) / 2) for k, v in amplitude_ranges.items()}, order=order)
  310. return ZernikeWavefront({k: rng.normal(loc=0, scale=(v[1] - v[0]) / 2) if rng.random() < 0.3 else 0 for k, v in amplitude_ranges.items()}, order=order)

zernike.py at commit 81262de, under MIT · at the source

Overview

Authors: Xiangzhang Cheng1,2, Bo Wang2, Li Luo2, Zhaowei Sun2,3, Sicong He2
ORCID iDs: Sicong He
  1. Department of Biomedical Engineering, Southern University of Science and Technology,Shenzhen, China
  2. Department of Immunology and Microbiology, School of Life Sciences, Southern University of Science and Technology,Shenzhen, China
  3. Division of Life Science, The Hong Kong University of Science and Technology, Clear Water Bay,Kowloon, Hong Kong China
Institutions: Southern University of Science and Technology (China); Hong Kong University of Science and Technology (Hong Kong SAR China)
Journal: Nature communications, volume 17, issue 1, article 6651
Dates: received 4 September 2025; accepted 11 May 2026; published online 20 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-73389-2 · PMID 42161926 · PMCID PMC13381939 · OpenAlex W7161784556
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), optical imaging (calcium, voltage, 2-photon) (modality), mouse (organism), zebrafish (organism)
Methods: Spectral & time-frequency, Evoked potentials, Machine learning, fMRI & imaging, Single-unit activity, calcium imaging, Physiology & signal measures
Keywords: Multiphoton microscopy, Fluorescence imaging
MeSH: Intravital Microscopy*, Optical Imaging*, Optics and Photonics*, Animals, Brain, Calcium, Eye, Image Processing, Computer-Assisted, Male, Mice, Microglia, Neurons, Visual Cortex, Zebrafish (* major topic)
Topic: Advanced Fluorescence Microscopy Techniques (Biophysics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Natural Science Foundation of China (National Science Foundation of China) (32192400); Guangdong Innovative and Entrepreneurial Research Team Program (2021ZT09Y104)
Citations: not cited yet (Europe PMC); 101 references in the paper

Abstract

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

Repositories

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

Zenodo 17118222

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 4 files
Software Heritage: not checked
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
At the source:

lukachan41/MeNet-AO

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 81262de3bf380b2c947f78ee5e22238baa9028fa, 30 December 2025
Languages: Python (19), Jupyter (5)
Size: 45 files, 24 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt), 5 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (16 files), Matplotlib (9 files), SciPy (8 files), Keras (4 files), OpenCV (4 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
26 files
At the source: github.com/lukachan41/MeNet-AO

Zenodo 19315205

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (16 files), Matplotlib (9 files), SciPy (8 files), Keras (4 files), OpenCV (4 files)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
26 files
At the source:

Code availability statement

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

  • it points to the authors' code: lukachan41/MeNet-AO, Zenodo 17118222, Zenodo 19315205
  • it says that the code is available on request

Read it in the paper: doi.org/10.1038/s41467-026-73389-2.

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:

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

Code and data availability statement

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

  • it points to the authors' code: lukachan41/MeNet-AO, Zenodo 17118222, Zenodo 19315205
  • it says that the data are available on request
  • it says that the code is available on request

Read it in the paper: doi.org/10.1038/s41467-026-73389-2.

Versions

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

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 2 keywords, 14 MeSH terms, 2 funders, 93 references.

Cite

This paper

Cheng, X., Wang, B., Luo, L., Sun, Z., & He, S. (2026). Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue. Nature communications, 17(1), 6651. https://doi.org/10.1038/s41467-026-73389-2

BibTeX

@article{cheng2026physics,
author = {Cheng, Xiangzhang and Wang, Bo and Luo, Li and Sun, Zhaowei and He, Sicong},
title = {{Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue}},
journal = {Nature communications},
year = {2026},
month = may,
volume = {17},
number = {1},
pages = {6651},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-73389-2},
url = {https://doi.org/10.1038/s41467-026-73389-2},
pmid = {42161926},
pmcid = {PMC13381939}
}

RIS

TY - JOUR
AU - Cheng, Xiangzhang
AU - Wang, Bo
AU - Luo, Li
AU - Sun, Zhaowei
AU - He, Sicong
TI - Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/05/20
VL - 17
IS - 1
SP - 6651
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-73389-2
UR - https://doi.org/10.1038/s41467-026-73389-2
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-73389-2",
"type": "article-journal",
"title": "Physics-informed multi-encoder adaptive optics enables rapid aberration correction for intravital microscopy of deep complex tissue",
"container-title": "Nature communications",
"author": [
{
"family": "Cheng",
"given": "Xiangzhang"
},
{
"family": "Wang",
"given": "Bo"
},
{
"family": "Luo",
"given": "Li"
},
{
"family": "Sun",
"given": "Zhaowei"
},
{
"family": "He",
"given": "Sicong"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "6651",
"DOI": "10.1038/s41467-026-73389-2",
"PMID": "42161926",
"PMCID": "PMC13381939",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-73389-2",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
20
]
]
}
}

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.1016/j.isci.2026.116769 [code]
Graph-based modeling of optical system enables adaptive optics on dynamic samples with self-calibration.
Journal: iScience
In common: SciPy, Matplotlib, NumPy, 18 references
[2] doi:10.1038/s41467-026-73045-9 [code]
Aberration-aware 3D localization microscopy via self-supervised neural-physics learning.
Journal: Nature communications
In common: OpenCV, SciPy, Matplotlib, 1 other tool, histology / microscopy, 6 references
[3] doi:10.1038/s41467-026-69798-y [code]
Dual deconvolution in multiphoton structured illumination microscopy for deep-tissue super-resolution imaging.
Journal: Nature communications
In common: optical imaging (calcium, voltage, 2-photon), histology / microscopy, mouse, 7 references
[4] doi:10.1016/j.crmeth.2026.101476 [code]
Unsupervised deep learning enables blur-free resolution enhancement in two-photon microscopy.
Journal: Cell reports methods
In common: OpenCV, SciPy, Matplotlib, 1 other tool, optical imaging (calcium, voltage, 2-photon), histology / microscopy, mouse, 3 references
[5] 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: NumPy, optical imaging (calcium, voltage, 2-photon), histology / microscopy, mouse, 5 references
[6] doi:10.1038/s41592-026-03043-8 [code]
Designer indicators for two-photon recording of subthreshold voltage dynamics.
Journal: Nature methods
In common: SciPy, Matplotlib, NumPy, optical imaging (calcium, voltage, 2-photon), histology / microscopy, mouse, 3 references
[7] 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, SciPy, Matplotlib, 1 other tool, optical imaging (calcium, voltage, 2-photon), histology / microscopy, 2 references
[8] doi:10.1364/boe.600665 [code]
NeuroSeg-MF: robust neuron segmentation in two-photon Ca&lt;sup&gt;2+&lt;/sup&gt; imaging using multi-feature fusion and detection-guided SAM.
Journal: Biomedical optics express
In common: OpenCV, SciPy, Matplotlib, 1 other tool, optical imaging (calcium, voltage, 2-photon), 2 references
[9] doi:10.7554/elife.105081 [code]
Movie reconstruction from mouse visual cortex activity.
Journal: eLife
In common: OpenCV, SciPy, Matplotlib, 1 other tool, optical imaging (calcium, voltage, 2-photon), mouse, 2 references
[10] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: Keras, OpenCV, SciPy, 2 other tools, optical imaging (calcium, voltage, 2-photon), mouse

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.