OSCR

Automated ROI detection allows rapid quantification of synaptic activity across tens of thousands of synapses in cell culture.

A correction to this paper has been published: the notice, 42549241, from Europe PMC.

Code ↔ Paper

9 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 9 matches
  1. [1] § Methods › Signal extraction and normalization ↔ src/analyze_suite2p/detector_utility.py, lines 14–76 · score 0.87 · rolling median, Suite2p ROI detection, airPLS, fluorescence compared, raw fluorescence, baseline correction
  2. [2] § Methods › Baseline and calcium transient detection ↔ src/analyze_suite2p/detector_utility.py, lines 207–299 · score 0.78 · baseline fluorescence, peak detection, find peaks, detect peaks, stamps, prominence
  3. [3] § Results ↔ src/analyze_suite2p/detector_utility.py, lines 14–76 · score 0.70 · airPLS, raw fluorescence, standard deviations, baseline corrected, suite2p, mask
  4. [4] § Methods › Normalizing active synapses to neurite coverage ↔ src/analyze_suite2p/export_cellprofiler_skeletons.py, lines 66–141 · score 0.69 · Neurite coverage, CellProfiler, Normalized synapses, skeletonized, exported, Threshold
  5. [5] § Methods › Baseline and calcium transient detection ↔ src/analyze_suite2p/plotting_utility.py, lines 19–53 · score 0.67 · peak detection, find peaks, standard deviations, prominence, width, stamps
  6. [6] § Results › Chronic memantine treatment reduces synaptic calcium transient amplitude ↔ R_analysis/glmm_effect_functions.R, lines 407–489 · score 0.66 · 3–102, 7–124, 8–218, synaptic event, MGO, Forest
  7. [7] § Results › Synaptic calcium imaging detects differential effects of patient-derived NMDAR autoantibodies ↔ R_analysis/glmm_effect_functions.R, lines 407–489 · score 0.60 · 3–102, 7–124, 8–218, MGO, model, NMDAR
  8. [8] § Methods › Statistical analysis ↔ R_analysis/glmm_effect_functions.R, lines 97–182 · score 0.58 · glmmTMB, Gamma, GLMMs, log, fit, models
  9. [9] § Results ↔ src/analyze_suite2p/export_cellprofiler_skeletons.py, lines 66–141 · score 0.56 · Thresholded neurites, CellProfiler, normalizing synapse, Skeletonized, suite2p, dendritic

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 · 436 lines · 17 KB · GPL-3.0 · 3 matches

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. from scipy.signal import find_peaks
  4. import pandas as pd
  5. import scipy.signal as signal
  6. from scipy.stats import norm
  7. from analyze_suite2p import config_loader
  8. from BaselineRemoval import BaselineRemoval
  9. import os
  11. _DEFAULT_CONFIG = config_loader.load_json_config_file()
  12. config = _DEFAULT_CONFIG
  14. def calculate_deltaF(F_file, config, event_threshold = None, lambda_window = None):
  15. """
  16. Convert raw fluorescence (F.npy) into change in fluorescence compared to baseline (dF / F0).
  18. Args:
  19. -----------
  20. F_file : str
  21. Path to NumPy array containing raw flourescence (F.npy) trace from suite2p.
  22. config : SimpleNameSpace dictionary
  23. loaded automatically from config_loader.load_json_config_file(file = None)
  24. event_threshold : float, optional
  25. Threshold (in MAD units) to mask obvious events by multiplying threshold by standard deviation.
  26. The Default value is 2; smaller values will limit the number of baseline points used for correction.
  27. lambda_window :
  28. airPLS lambda value, smaller numbers result in more smoothing, a value of 10 or 100
  29. is recommended to start with
  30. Number of frames to subsample for rolling median calculation
  32. Returns:
  33. --------
  34. deltaF : 1D numpy array
  35. dF/F0 normalized fluorescence
  36. MAD baseline estimated
  37. ZhangFit / airPLS automated baseline correction
  38. deltaF is saved into the suite2p output folder generated from suite2p ROI detection.
  39. """
  41. savepath = rf"{F_file}".replace("\\F.npy","") ## make savepath original folder, indicates where deltaF.npy is saved
  42. F = np.load(rf"{F_file}", allow_pickle=True)
  43. Fneu = np.load(rf"{F_file[:-4]}"+"neu.npy", allow_pickle=True)
  44. deltaF= []
  45. if event_threshold is None:
  46. event_threshold = config.analysis_params.MAD_baseline_filter_threshold
  47. if lambda_window is None:
  48. lambda_window = config.analysis_params.lambda_window
  49. for f, fneu in zip(F, Fneu):
  50. corrected_trace = f - (0.7*fneu) ## neuropil correction
  52. #Remove bleaching to generate change in Fluorescence
  53. baseline_corrected = BaselineRemoval(corrected_trace)
  54. airPLS_corrected = baseline_corrected.ZhangFit(lambda_= lambda_window)
  56. #Determine baseline F0 value
  57. trace_median = np.median(corrected_trace)
  58. trace_mad = np.median(np.abs(corrected_trace - trace_median))
  59. norm_sigma = 1.4826*trace_mad
  60. baseline_mask = np.abs(corrected_trace - trace_median) < event_threshold * norm_sigma
  61. F0 = np.median(corrected_trace[baseline_mask])
  63. #calculate dF / F0
  64. normalized_F = (airPLS_corrected)/F0
  66. deltaF.append(normalized_F)
  68. deltaF = np.array(deltaF)
  69. deltaF = np.squeeze(deltaF)
  70. if not os.path.exists(f"{savepath}/deltaF.npy"):
  71. np.save(f"{savepath}/deltaF.npy", deltaF, allow_pickle=True)
  72. print(f"delta F traces saved as deltaF.npy under {savepath}\n")
  73. else:
  74. print(f"deltaF files already exist for {F_file[len(config.general_settings.main_folder)+1:-21]}")
  76. return deltaF
  78. def rolling_correction_deltaF(F_file, config, event_threshold = None, lambda_window = None):
  79. """
  80. Convert raw fluorescence (F.npy) into change in fluorescence compared to baseline (dF / F0)
  81. using rolling median baseline correction.
  83. Args:
  84. -----------
  85. F_file : str
  86. Path to NumPy array containing raw flourescence (F.npy) trace from suite2p.
  87. config : SimpleNameSpace dictionary
  88. loaded automatically from config_loader.load_json_config_file(file = None)
  89. event_threshold : float, optional
  90. Number of standard deviations above MAD to se peak filtering; default is 2
  91. lambda_window : int, optional
  92. Number of frames to subsample for rolling median calculation
  94. Returns:
  95. --------
  96. deltaF : 1D numpy array
  97. dF/F0 normalized fluorescence
  98. MAD baseline estimated
  99. rolling median automated baseline correction
  100. deltaF is saved into the suite2p output folder generated from suite2p ROI detection.
  101. """
  102. savepath = rf"{F_file}".replace("\\F.npy","") ## make savepath original folder, indicates where deltaF.npy is saved
  103. F = np.load(rf"{F_file}", allow_pickle=True)
  104. Fneu = np.load(rf"{F_file[:-4]}"+"neu.npy", allow_pickle=True)
  105. deltaF= []
  106. if event_threshold is None:
  107. event_threshold = config.analysis_params.MAD_baseline_filter_threshold
  108. if lambda_window is None:
  109. lambda_window = config.analysis_params.lambda_window
  110. for f, fneu in zip(F, Fneu):
  111. corrected_trace = f - (0.7*fneu) ## neuropil correction
  113. #Remove bleaching to generate change in Fluorescence
  115. baseline_corrected = remove_bleaching(corrected_trace, 'rolling_med', window = lambda_window) #TODO make interatable with config file
  117. #Determine baseline F0 value
  118. trace_median = np.median(corrected_trace)
  119. trace_mad = np.median(np.abs(corrected_trace - trace_median))
  120. norm_sigma = 1.4826*trace_mad
  121. baseline_mask = np.abs(corrected_trace - trace_median) < event_threshold * norm_sigma
  122. F0 = np.median(corrected_trace[baseline_mask])
  124. #calculate dF / F0
  125. normalized_F = (baseline_corrected)/F0
  127. deltaF.append(normalized_F)
  129. deltaF = np.array(deltaF)
  130. deltaF = np.squeeze(deltaF)
  131. if not os.path.exists(f"{savepath}/deltaF.npy") and not config.analysis_params.overwrite_suite2p:
  132. np.save(f"{savepath}/deltaF.npy", deltaF, allow_pickle=True)
  133. print(f"delta F traces saved as deltaF.npy under {savepath}\n")
  134. elif os.path.exists(f"{savepath}/deltaF.npy") and config.analysis_params.overwrite_suite2p:
  135. np.save(f"{savepath}/deltaF.npy", deltaF, allow_pickle=True)
  136. print(f"delta F traces saved as deltaF.npy under {savepath}\n")
  137. else:
  138. print(f"deltaF files already exist for {F_file[len(config.general_settings.main_folder)+1:-21]}")
  140. return deltaF
  143. def estimate_single_trace_baseline_noise_mad(F_trace, event_threshold = 2):
  144. """
  145. Estimate noise sigma from baseline-only windows using MAD.
  147. Args:
  148. -----------
  149. F : 1D numpy array
  150. Baseline-corrected ΔF/F trace.
  151. frame_rate : float
  152. Sampling rate (Hz).
  153. event_threshold : float
  154. Preserved from calculate_deltaF function above.
  155. Threshold (in MAD units) to mask obvious events by multiplying by estimated noise standard deviation.
  156. Default: 2 (SD above median)
  157. Smaller values will limit the number of baseline points used for correction.
  158. min_baseline_sec : float
  159. Minimum duration (seconds) of a baseline window.
  160. Default: 10 s
  162. Returns:
  163. --------
  164. sigma : float
  165. Estimated noise standard deviation.
  166. baseline_mask : boolean array
  167. Mask of samples classified as baseline.
  168. """
  170. trace_median = np.median(F_trace)
  171. mad = np.median(np.abs(F_trace - trace_median))
  172. sigma = 1.4826 * mad
  173. event_mask = np.abs(F_trace - trace_median) > event_threshold * sigma
  175. trace_baseline = ~event_mask
  177. baseline_samples = F_trace[trace_baseline]
  179. baseline_median = np.median(baseline_samples)
  180. baseline_mad = np.median(np.abs(baseline_samples - baseline_median))
  181. sigma = 1.4826 * baseline_mad
  183. return sigma, baseline_samples
  185. def filter_outliers(trace):
  186. """
  187. Filter outliers (peaks) from calcium trace using the trace IQR
  189. Args:
  190. -----------
  191. trace : 1D numpy array
  192. Fluorescence trace (e.g., F.npy) from suite2p output.
  194. Returns:
  195. --------
  196. filtered_values : 1D array
  197. values from 1D array that fall within the original trace IQR.
  198. """
  199. q1,q3 = np.percentile(trace, [25,75])
  200. iqr = q3-q1
  201. lower_bound = q1 - 1.5*iqr
  202. upper_bound = q3 + 1.5*iqr
  203. filtered_values = trace[(trace >= lower_bound) & (trace <= upper_bound)]
  204. return filtered_values
  207. def single_synapse_peak_detection(deltaF, return_peaks = False,
  208. return_decay_frames = False,
  209. return_amplitudes = False,
  210. return_decay_time = False,
  211. return_peak_count = False,
  212. extract_peaks = False):
  213. """
  214. Identify time stamps and metrics of individual calcium spikes for a single ROI.
  216. Args:
  217. -----------
  218. deltaF : 1D numpy array
  219. Normalized fluroescence trace
  220. return_peaks : bool, optional
  221. Returns time stamps (frame) for each peak
  222. return_decay_frames : bool, optional
  223. Returns time stamp (frame) for when each peak returns to threshold
  224. if no return to threshold --> returns NaN
  225. return_amplitudes : bool, optional
  226. Returns normalized amplitude for each detected peak
  227. return_decay_times : bool, optional
  228. Returns decay time from peak frame to crossing threshold (in seconds)
  229. return_peak_count : bool, optional
  230. Returns len(peaks)
  231. extract_peaks : bool, optional
  232. Returns peaks + 30 frames for peak library --> to be used for Tau calculations
  234. Returns:
  235. --------
  236. IF any==True :
  237. return_peaks : returns calcium spike time_stamps
  238. return_decay_frames : returns number of frames for calcium spike to decay to threshold
  239. return_amplitudes : returns amplitude of calcium spike in relation to baseline fluorescence (F0)
  240. return_decay_time : returns decay time in seconds (converts number of frames into seconds)
  241. return_peak_count : returns the total number of calcium spikes for the ROI fluorescence trace
  242. extract_peaks : returns deltaF window around calcium spike for calcium spike library
  243. """
  245. sigma, deltaF_baseline = estimate_single_trace_baseline_noise_mad(deltaF, event_threshold=2)
  247. baseline_reference = np.median(deltaF_baseline)
  248. peak_detection_multiplier = 4.5# float(config.analysis_params.peak_detection_threshold)
  249. threshold = np.median(deltaF_baseline) + (peak_detection_multiplier * sigma)
  251. peaks, _ = find_peaks(deltaF, height = threshold, distance = 5, prominence = baseline_reference + sigma, width = (2,None))
  252. amplitudes = deltaF[peaks] - baseline_reference #amplitude
  253. peak_count = len(peaks)
  254. negative_points = np.where((deltaF < threshold))[0]
  256. # print(negative_points)
  257. decay_points = []
  258. decay_time = []
  260. if return_decay_time:
  261. for peak1, peak2 in zip(peaks[:-1], peaks[1:]):
  262. negative_between_peaks = negative_points[negative_points>peak1]
  263. negative_between_peaks = negative_between_peaks[negative_between_peaks<peak2]
  264. if len(negative_between_peaks)>0:
  265. decay_points.append(negative_between_peaks[0])
  266. if len(negative_between_peaks)==0:
  267. decay_points.append(np.nan)
  268. if len(peaks)>0:
  269. negative_after_last_peak = negative_points[negative_points>peaks[-1]]
  270. if len(negative_after_last_peak)>0:
  271. decay_points.append(negative_after_last_peak[0])
  272. else:
  273. decay_points.append(np.nan)
  274. else:
  275. decay_points = []
  277. for peak,decay in zip(peaks, decay_points):
  278. decay_time.append(np.abs(decay - peak)/config.general_settings.frame_rate) #import framerate
  280. decay_points = np.array(decay_points) #decay frames crossing baseline
  281. decay_time = np.array(decay_time) #seconds after a calcium peak to return to baseline
  283. if return_peaks == True:
  284. return peaks
  285. if return_decay_frames == True:
  286. return decay_points
  287. if return_amplitudes == True:
  288. return amplitudes
  289. if return_decay_time == True:
  290. return decay_time
  291. if return_peak_count == True:
  292. return peak_count
  293. if extract_peaks:
  294. peak_dict = {}
  295. #TODO fix up these points for peak library
  296. # for peak in peaks:
  297. # peak_dict.update(f'peak_{peak}': 'deltaF[peak:peak+30]')
  299. return peak_dict
  302. def detect_spikes_by_mod_z(input_trace, **signal_kwargs):
  303. """
  304. Detect spikes by median absolute difference (MAD) of each frame from median of the trace.
  306. Args:
  307. -----------
  308. input_trace : 1D NumPy array
  309. **signal_kwargs : assorted see signal.find_peaks()
  310. Ex. width = (min,max), peak_prominence = type(float), height = type(float), threshold = type(float), distance = int/float
  311. Returns:
  312. --------
  313. peak time frames using signal.find_peaks() function
  315. """
  316. median = np.median(input_trace)
  317. deviation_from_med = np.array(input_trace) - median
  318. mad = np.median(np.abs(deviation_from_med))
  319. mod_zscore = deviation_from_med/(1.4826*mad)
  320. return signal.find_peaks(mod_zscore, **signal_kwargs)[0]
  323. def plot_spikes(raw_trace, detector_func, detector_trace=None, **detector_kwargs):
  324. """
  325. Plot ROI calcium trace with overlayed detected spikes as red vertical lines.
  327. Args:
  328. -----------
  329. raw_trace : 1D NumPy array
  331. detector_func : Function
  332. Ex. scipy.signal.find_peaks() / detect_spikes_by_mod_z()
  334. detector_trace : bool, optional
  336. **detector_kwargs : assorted, optional
  337. Ex. scipy.signal.find_peaks(x, height = , threshold = , peak_prominence = , width = , distance = )
  339. Returns:
  340. --------
  341. matplotlib.pyplot.plot line graph
  342. blue : detector_trace (if true) or raw trace
  343. red : detected spikes
  344. """
  345. if detector_trace is None:
  346. detector_input_trace = raw_trace.copy()
  347. else:
  348. detector_input_trace = detector_trace.copy()
  349. spikes = detector_func(detector_input_trace, **detector_kwargs)
  350. plt.plot(range(len(raw_trace)), raw_trace, color="blue")
  351. for spk in spikes:
  352. plt.axvline(spk, color="red")
  353. plt.show()
  356. def rolling_min(input_series, window_size):
  357. """
  358. Calculate rolling minimum value (input_series.rolling()) over different windows of the input trace.
  360. Args:
  361. -----------
  362. input_series : 1D NumPy array
  363. raw_trace / F.npy / deltaF.npy
  364. window_size : int
  365. Size of window to measure with each iteration
  367. Returns:
  368. --------
  369. m : int / float
  370. Smallest local minimum across all windows
  371. """
  372. r = input_series.rolling(window_size, min_periods=1)
  373. m = r.min()
  374. return m
  376. def rolling_med(input_series, window_size):
  377. """
  378. Calculate rolling minimum value (input_series.rolling()) over different windows of the input trace.
  380. Args:
  381. -----------
  382. input_series : 1D NumPy array
  383. raw_trace / F.npy / deltaF.npy
  384. window_size : int
  385. Size of window to measure with each iteration
  387. Returns:
  388. --------
  389. m : int / float
  390. Smallest local minimum across all windows
  391. """
  392. r = input_series.rolling(window_size, min_periods=1)
  393. m = r.median()
  394. return m
  396. def remove_bleaching(input_trace, baseline_correction, window = None):
  397. """
  398. Basic first-order polynomial function to remove bleaching from single ROI calcium imaging trace
  400. Args:
  401. -----------
  402. input_trace : 1D array
  403. raw fluorescence trace (F.npy or corrected: F.npy - 0.7*Fneu.npy)
  404. functions by processing one ROI at a time
  405. baseline_correction : str
  406. String name of function to call for removing bleaching from fluorescence trace
  407. Accepts 'rolling_min' or 'rolling_med' as possible values; all other values will break the function
  409. Returns:
  410. --------
  411. input_trace - fit(range(len(input_trace)))
  412. input trace adjusted by rolling minimum
  413. polynomial fit built on length of trace, rolling min values, and order of polynomial (e.g. 2nd)
  414. poly1d fits a 1 dimensional polynomial to the adjusted trace which is subtraced from the raw trace (input_Trace)
  416. """
  417. possible_corrections = ['rolling_min', 'rolling_med']
  418. if baseline_correction not in possible_corrections:
  419. print(f"Please enter a valid correction method: {possible_corrections}")
  420. return
  422. if baseline_correction == "rolling_min":
  423. if window is not None:
  424. corr_trace = rolling_min(pd.Series(input_trace), window_size = int(window))
  425. else:
  426. corr_trace = rolling_min(pd.Series(input_trace), window_size=int(len(input_trace)/10))
  427. if baseline_correction == "rolling_med":
  428. if window is not None:
  429. corr_trace = rolling_med(pd.Series(input_trace), window_size = int(window))
  430. else:
  431. corr_trace = rolling_med(pd.Series(input_trace), window_size = int(len(input_trace)/10))
  432. # fit_coefficients = np.polyfit(range(len(corr_trace)), corr_trace, 2)
  433. # fit = np.poly1d(fit_coefficients)
  434. # return input_trace - fit(range(len(input_trace)))
  435. return input_trace - corr_trace

detector_utility.py at commit ae19f9c, under GPL-3.0 · at the source

Overview

Authors: John Carl Begley1,2,3,4, Harald Prüss2,5, Paul Turko4, Camin Dean2,3,6
ORCID iDs: Paul Turko
  1. Institute of Biology, Humboldt-Universität zu Berlin, Berlin, Germany
  2. German Center for Neurodegenerative Diseases (DZNE) Berlin, Berlin, Germany
  3. Einstein Center for Neurosciences Berlin, Berlin, Germany
  4. Shared Primary Neuron Facility (SPNF), Institute for Integrative Neuroanatomy, Charité – Universitätsmedizin, Berlin, Germany
  5. Department of Neurology and Experimental Neurology, Charité – Universitätsmedizin Berlin, Berlin, Germany
  6. Bernstein Center for Computational Neuroscience Berlin, Berlin, Germany
Institutions: German Center for Neurodegenerative Diseases (Germany); Humboldt-Universität zu Berlin (Germany); Einstein Center for Neurosciences Berlin (Germany); Charité - Universitätsmedizin Berlin (Germany); Bernstein Center for Computational Neuroscience Berlin (Germany)
Journal: Frontiers in synaptic neuroscience, volume 18, article 1832103
Dates: received 16 March 2026; accepted 12 May 2026; published online 28 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnsyn.2026.1832103 · PMID 42291802 · PMCID PMC13254171 · OpenAlex W7162628158
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: optical imaging (calcium, voltage, 2-photon) (modality), cellular / molecular (subfield)
Methods: Connectivity, Statistics, Preprocessing, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: calcium imaging, NMDAR auto-antibodies, automated ROI detection, presynaptic function, post-synaptic function
Topic: Neuroscience and Neuropharmacology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 73 references in the paper
Notices: A correction to this paper has been published (42549241, from Europe PMC)

Abstract

Synapses are the basic unit of information transfer between neurons. Their dysfunction is a common trigger of cognitive diseases and disorders. However, high-throughput analysis methods to assess synaptic function and dysfunction are lacking. Calcium imaging in cultured neurons in the absence of Mg2+ and presence of TTX allows visualization of NMDAR-dependent spontaneous synaptic calcium transients, which report pre and postsynaptic function. Here, we introduce a high-throughput automated analysis pipeline that combines Suite2p ROI detection and Python scripts to analyze tens of thousands of synapses and quantify changes in presynaptic vesicle fusion rates (frequency), postsynaptic function (amplitude), and the number of functional synapses. We use this pipeline to test known NMDAR agonists (glycine) and antagonists (ketamine, memantine, APV), presynaptic function modulating compounds (PDBu), and encephalitis patient-derived NMDAR auto-antibodies, where our pipeline proved more sensitive in detecting dysfunction at the single-synapse level than other methods. The ability to detect, track, and quantify activity across tens of thousands of synapses and millions of synaptic calcium transients using this pipeline will aid drug discovery of compounds that protect synapse function.

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

jay-cee-begs/synaptic_suite2p

License: GPL-3.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: ae19f9c5c61e324f5fb03c3cfe6d6ab73809af81, 29 May 2026
Languages: Python (19), R (2), Jupyter (1)
Size: 42 files, 22 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (setup.py), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (9 files), pandas (8 files), Matplotlib (5 files), ggplot2 (2 files), SciPy (2 files), tidyverse (2 files), broom (1 file), easystats (1 file), glmmTMB (1 file), Pillow (1 file), seaborn (1 file), Suite2p (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
24 files
At the source: github.com/jay-cee-begs/synaptic_suite2p

Code availability

The code for synapse analysis in Python, neurite length measurement in CellProfiler, and R mixed-effect models is available here (https://github.com/jay-cee-begs/synaptic_suite2p).

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

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;
  • 22 scripts, each with its path and the digest of its content;
  • 9 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 raw data supporting the conclusions of this article will be made available by the authors without undue reservation.

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, 28 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 4 authors, 5 keywords, 70 references, 1 integrity notice.

Cite

This paper

Begley, J. C., Prüss, H., Turko, P., & Dean, C. (2026). Automated ROI detection allows rapid quantification of synaptic activity across tens of thousands of synapses in cell culture. Frontiers in synaptic neuroscience, 18, 1832103. https://doi.org/10.3389/fnsyn.2026.1832103

BibTeX

@article{begley2026automated,
author = {Begley, John Carl and Prüss, Harald and Turko, Paul and Dean, Camin},
title = {{Automated ROI detection allows rapid quantification of synaptic activity across tens of thousands of synapses in cell culture}},
journal = {Frontiers in synaptic neuroscience},
year = {2026},
month = may,
volume = {18},
pages = {1832103},
publisher = {Frontiers Media SA},
issn = {1663-3563},
doi = {10.3389/fnsyn.2026.1832103},
url = {https://doi.org/10.3389/fnsyn.2026.1832103},
pmid = {42291802},
pmcid = {PMC13254171}
}

RIS

TY - JOUR
AU - Begley, John Carl
AU - Prüss, Harald
AU - Turko, Paul
AU - Dean, Camin
TI - Automated ROI detection allows rapid quantification of synaptic activity across tens of thousands of synapses in cell culture
T2 - Frontiers in synaptic neuroscience
J2 - Front Synaptic Neurosci
PY - 2026
DA - 2026/05/28
VL - 18
SP - 1832103
SN - 1663-3563
PB - Frontiers Media SA
DO - 10.3389/fnsyn.2026.1832103
UR - https://doi.org/10.3389/fnsyn.2026.1832103
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnsyn.2026.1832103",
"type": "article-journal",
"title": "Automated ROI detection allows rapid quantification of synaptic activity across tens of thousands of synapses in cell culture",
"container-title": "Frontiers in synaptic neuroscience",
"author": [
{
"family": "Begley",
"given": "John Carl"
},
{
"family": "Prüss",
"given": "Harald"
},
{
"family": "Turko",
"given": "Paul"
},
{
"family": "Dean",
"given": "Camin"
}
],
"container-title-short": "Front Synaptic Neurosci",
"volume": "18",
"page": "1832103",
"DOI": "10.3389/fnsyn.2026.1832103",
"PMID": "42291802",
"PMCID": "PMC13254171",
"ISSN": "1663-3563",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnsyn.2026.1832103",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
28
]
]
}
}

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/s41514-026-00391-9 [code]
Region-specific transcriptional signatures of brain aging in the absence of neuropathology at the single-cell level.
Journal: npj aging
In common: glmmTMB, broom, ggplot2, 6 other tools, cellular / molecular, 1 reference
[2] doi:10.1126/sciadv.aec2042 [code]
IgLON5 autoimmune antibodies activate Tau via neuronal hyperactivity.
Journal: Science advances
In common: tidyverse, cellular / molecular, 3 references, author Paul Turko
[3] doi:10.1016/j.isci.2026.116206 [code]
Gut distension evokes rapid neural dynamics in vagal and hindbrain populations of larval zebrafish.
Journal: iScience
In common: Suite2p, Pillow, seaborn, 4 other tools, optical imaging (calcium, voltage, 2-photon), 1 reference
[4] doi:10.7554/elife.107088 [code]
Development of auditory and spontaneous movement responses to music over the first postnatal year.
Journal: eLife
In common: glmmTMB, easystats, ggplot2, 6 other tools
[5] doi:10.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: easystats, broom, ggplot2, 6 other tools, 1 reference
[6] doi:10.1016/j.celrep.2026.117505 [code]
Impaired spatial coding and neuronal hyperactivity in the medial entorhinal cortex of aged APP knock-in mice.
Journal: Cell reports
In common: glmmTMB, easystats, broom, 5 other tools
[7] doi:10.1002/hbm.70605 [code]
BrainEnrich: Revealing Biological Insights for Imaging-Derived Phenotypes Through Transcriptomic Enrichment.
Journal: Human brain mapping
In common: easystats, broom, ggplot2, 6 other tools
[8] doi:10.1093/cercor/bhag113 [code]
Long-term reliability and stability of parameterized resting state EEG: evidence from a five-year follow-up.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: easystats, broom, ggplot2, 6 other tools
[9] doi:10.1038/s41467-026-73865-9 [code]
Histamine shapes the neurocomputational dynamics of human learning.
Journal: Nature communications
In common: easystats, broom, ggplot2, 6 other tools
[10] doi:10.1038/s41467-026-70287-5 [code]
Cortical-limbic circuit dynamics of approach-avoidance conflict in humans.
Journal: Nature communications
In common: easystats, broom, ggplot2, 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.