OSCR

Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to <i>CRB1</i>: Implications for Clinical Trials.

Code ↔ Paper

10 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 10 matches
  1. [1] § Methods › Data analysis › Analysis of ssVEP data › Validity and reliability ↔ 02_data_analysis/src/04_reliability/CRB1_ssVEP_retest_analysis.ipynb, lines 1–54 · score 0.78 · intraclass correlation, original segment, epoched EEG, reliability assessment, coefficients, replacement
  2. [2] § Methods › Data analysis › Preprocessing ↔ 01_eeg_preprocessing/src/subject_level_eeg_analysis/utils.py, lines 339–387 · score 0.77 · neighboring frequency bins, power spectral density, immediate neighbors, PSD spectrum, noise, epochs
  3. [3] § Methods › Data analysis › Preprocessing ↔ 01_eeg_preprocessing/src/subject_level_eeg_analysis/utils.py, lines 339–387 · score 0.76 · neighboring frequency bins, power spectral density, immediate neighbors, noise, epochs, spectrum
  4. [4] § Methods › Data analysis › Analysis of ssVEP data › Comparisons of the ssVEP curve shape ↔ 02_data_analysis/src/02_analysis/03_fitCSF.Rmd, lines 95–210 · score 0.64 · peak gain, contrast sensitivity, maximal, likelihood, fitting, Gmax
  5. [5] § Methods › Participants ↔ 02_data_analysis/src/02_analysis/01_Demographics.Rmd, lines 54–86 · score 0.61 · disease duration, sighted control, gender, Demographic, females, SD
  6. [6] § Methods › ssVEP assessment: stimuli and paradigm ↔ src/optoflicker23/experiment.py, lines 47–141 · score 0.57 · refresh rate, gamma, PsychoPy, setup, gratings, position
  7. [7] § Methods › Data analysis › Analysis of ssVEP data › Validity and reliability ↔ 02_data_analysis/src/02_analysis/04_Correlation.Rmd, lines 94–141 · score 0.57 · linear mixed model, Categorical acuity, ssVEP, correlation, AUC, eyes
  8. [8] § Methods › Data analysis › Analysis of ssVEP data › Validity and reliability ↔ 02_data_analysis/src/02_analysis/06_Supplementary_PhenoComp_CRDexcl.Rmd, lines 659–697 · score 0.57 · linear mixed model, Categorical acuity, ssVEP, AUC, correlation, eyes
  9. [9] § Methods › Data analysis › Analysis of ssVEP data › Comparisons of overall ssVEP response ↔ 02_data_analysis/src/02_analysis/01_Demographics.Rmd, lines 394–484 · score 0.56 · Monte Carlo, CRB1 subgroups, permutation, eyes
  10. [10] § Methods › ssVEP assessment: stimuli and paradigm ↔ src/optoflicker23/experiment.py, lines 298–383 · score 0.51 · Visual stimuli, coin, jittered, sound, cycle, duration

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 · 728 lines · 23 KB · no license · 2 matches

  1. import tempfile
  2. from datetime import datetime, timedelta
  3. from copy import deepcopy
  4. import pyedflib
  5. from pyedflib.highlevel import write_edf
  6. from pyedflib import highlevel
  7. import os
  8. import mne
  9. import mne_bids
  10. import pandas as pd
  11. import numpy as np
  12. from typeguard import typechecked
  13. from joblib import Parallel, delayed
  14. from typing import Union, Dict
  15. from matplotlib import pyplot as plt
  16. from matplotlib.backends.backend_pdf import PdfPages
  17. from matplotlib.figure import Figure
  18. from yaml import safe_load
  19. from pathlib import Path
  20. import inspect
  23. @typechecked
  24. def ensure_dir(file_path: os.PathLike):
  25. directory = os.path.dirname(file_path)
  26. if not os.path.exists(directory):
  27. os.makedirs(directory)
  30. @typechecked
  31. def select_epochs(epochs: mne.BaseEpochs, events: pd.DataFrame, func: callable, **kwargs) -> mne.BaseEpochs:
  32. """
  33. Convenience function to select epochs based on events and a lambda function. The function should take a single argument,
  34. which is a pandas DataFrame containing the events. The function should return a boolean array
  35. of the same length as the events DataFrame. The boolean array indicates which events should be selected.
  37. Parameters
  38. ----------
  39. epochs : mne.Epochs
  40. Epochs.
  41. events : pd.DataFrame
  42. Events.
  43. func : callable
  44. Function to select epochs.
  45. **kwargs :
  46. Additional arguments passed to func.
  48. Returns
  49. -------
  50. mne.Epochs
  51. Selected epochs.
  52. """
  53. # check that events and epochs have the same length
  54. assert len(events) == len(
  55. epochs), "Events and epochs must have the same length."
  57. # select events
  58. select = func(events, **kwargs)
  60. # convet select to a list of conditions
  61. select = events["id"][select].unique().astype(str).tolist()
  63. # select epochs
  64. _epochs = epochs[select]
  66. return _epochs
  69. # define a decorator that vectorizes a function by calling the wrapped function for each element of the inputs lists
  70. # this is applied to all arguments that are lists and are longer than 1. errors are raised if the lists are not of equal length
  73. def vectorize(func: callable) -> callable:
  74. """
  75. Decorator that vectorizes a function by calling the wrapped function for each element of the inputs lists.
  76. This is applied to all arguments that are lists and are longer than 1. Errors are raised if the lists are not of equal length.
  78. Parameters
  79. ----------
  80. func : callable
  81. Function to vectorize.
  83. Returns
  84. -------
  85. callable
  86. Vectorized function.
  87. """
  88. def wrapper(*args, **kwargs):
  90. # check for 'n_jobs' argument
  91. if "n_jobs" in kwargs:
  92. # if a single number is passed, just use that number of jobs
  93. if isinstance(kwargs["n_jobs"], int):
  94. n_jobs = kwargs["n_jobs"]
  95. del kwargs["n_jobs"]
  96. # if a tuple is passed, use the first element for the number of jobs here and pass the second element to the function
  97. elif isinstance(kwargs["n_jobs"], list):
  98. n_jobs = kwargs["n_jobs"][0]
  99. kwargs["n_jobs"] = kwargs["n_jobs"][1]
  100. else:
  101. n_jobs = 1
  103. # find all arguments that are lists and are longer than 1
  104. lists = [arg for arg in args if isinstance(arg, list) and len(arg) > 1]
  106. if len(lists) == 0:
  107. # unlists lists with a single element
  108. args = [arg[0] if (isinstance(arg, list) and len(
  109. arg) == 1) else arg for arg in args]
  110. # no lists found, call the function
  111. return func(*args, **kwargs)
  113. # check that all lists are of equal length
  114. assert all(len(l) == len(lists[0])
  115. for l in lists), "All lists must be of equal length"
  117. # create a list of arguments topass for very iteration of the function
  118. outer_args = []
  120. for i in range(len(lists[0])):
  121. inner_args = []
  122. outer_args.append(inner_args)
  123. for arg in args:
  124. if isinstance(arg, list):
  125. inner_args.append(arg[i])
  126. else:
  127. inner_args.append(arg)
  129. # iter over all elements of the lists. use parallelization if n_jobs is set to a number > 1
  130. if n_jobs > 1 or n_jobs < 0:
  131. print("Running {} iterations of {} in parallel using {} jobs.".format(
  132. len(outer_args), func.__name__, n_jobs))
  133. return Parallel(n_jobs=n_jobs)(delayed(func)(*inner_args, **kwargs) for inner_args in outer_args)
  134. else:
  135. return [func(*inner_args, **kwargs) for inner_args in outer_args]
  137. return wrapper
  140. @typechecked
  141. def session_dict_to_lists(d: dict[str, list[str]]) -> (list[str], list[str]):
  142. """
  143. Convert a dictionary to a list of tuples. The dictionary keys are the first element of the tuples, and the dictionary values are the second element of the tuples.
  145. Parameters
  146. ----------
  147. d : dict[str, list[str]]
  148. Dictionary of subject/session combinations. The keys are the subjects, and the values are lists of sessions.
  150. Returns
  151. -------
  152. list[str]
  153. List of subjects (one element per subject/session combination).
  154. list[str]
  155. List of sessions (one element per subject/session combination).
  156. """
  157. sessions = []
  158. subjects = []
  159. for subject, session_list in d.items():
  160. for session in session_list:
  161. subjects.append(subject)
  162. sessions.append(session)
  164. return subjects, sessions
  167. @typechecked
  168. def get_events_as_data_frame(raw: mne.io.BaseRaw, events: np.ndarray) -> pd.DataFrame:
  169. """
  170. Get events as a pandas DataFrame.
  172. Parameters
  173. ----------
  174. raw : mne.Raw
  175. Raw data.
  176. events : np.ndarray
  177. Events.
  179. Returns
  180. -------
  181. pd.DataFrame
  182. Events as a pandas DataFrame.
  183. """
  184. # convert events to a data frame
  185. events_df = pd.DataFrame(
  186. events, columns=["onset_sample", "duration", "event_id"])
  188. # add the time of each event
  189. events_df["onset"] = raw.times[events_df["onset_sample"] - raw.first_samp]
  191. return events_df
  194. @typechecked
  195. class AnalysisLogger:
  196. def __init__(self, file: os.PathLike, verbose: bool = False):
  197. """
  198. Create a logger that logs messages to a file and optionally prints them to the console.
  200. Parameters
  201. ----------
  202. file : os.PathLike
  203. Path to the log file.
  204. verbose : bool, optional
  205. If True, print messages to the console. The default is False.
  206. Returns
  207. -------
  208. None.
  209. """
  210. self.file = file
  211. self.verbose = verbose
  213. def log(self, msg: str, verbose: bool = None, to_file=True) -> None:
  214. """
  215. Print a message if verbose is True.
  217. Parameters
  218. ----------
  219. msg : str
  220. Message to print.
  221. verbose : bool, optional
  222. If True, print the message. The default is self.verbose.
  223. to_file : bool, optional
  224. If True, write the message to the log file. The default is True.
  226. Returns
  227. -------
  228. None.
  229. """
  230. if verbose is None:
  231. verbose = self.verbose
  233. if verbose:
  234. print(msg)
  236. def log_file(self, msg: str) -> None:
  237. """
  238. Write a message to the log file.
  240. Parameters
  241. ----------
  242. msg : str
  243. Message to write.
  245. Returns
  246. -------
  247. None.
  248. """
  249. with open(self.file, "a") as f:
  250. f.write(msg + "\n")
  253. @typechecked
  254. def df_append(df: pd.DataFrame, d: dict) -> pd.DataFrame:
  255. """
  256. Append a dictionary to a DataFrame.
  258. Parameters
  259. ----------
  260. df : pd.DataFrame
  261. DataFrame.
  262. d : dict
  263. Dictionary.
  265. Returns
  266. -------
  267. pd.DataFrame
  268. DataFrame with the dictionary appended.
  269. """
  271. # append() is no longer supported in pandas
  273. # convert the dictionary to a DataFrame
  274. _d = pd.DataFrame.from_records(d, index=[0])
  276. # append the DataFrame to the DataFrame
  277. return pd.concat([df, _d], ignore_index=True)
  280. def find_matching_paths(*args, expected_num=-1, **kwargs) -> list[mne_bids.BIDSPath]:
  281. """
  282. Find all files matching the arguments.
  284. Parameters
  285. ----------
  286. *args :
  287. Arguments passed to mne_bids.find_matching_paths.
  288. expected_num : int, optional
  289. Expected number of files. If set to -1, no check is performed. The default is -1.
  290. **kwargs :
  291. Keyword arguments passed to mne_bids.find_matching_paths.
  293. Returns
  294. -------
  295. list[mne_bids.BIDSPath]
  296. List of matching files.
  297. """
  299. files = mne_bids.find_matching_paths(*args, **kwargs)
  301. # make sure that all files are unique
  302. ofiles = []
  303. for f in files:
  304. if f.fpath not in [f.fpath for f in ofiles]:
  305. ofiles.append(f)
  307. if expected_num > -1:
  308. assert len(
  309. ofiles) == expected_num, f"Found {len(ofiles)} files while expecting {expected_num}."
  311. return ofiles
  314. @typechecked
  315. def save_combined_pdf(fname: Union[str, bytes, os.PathLike], figs: list[Figure]) -> None:
  316. """
  317. Save a list of matplotlib figures as a single pdf file using PdfPages.
  319. Parameters
  320. ----------
  321. fname : Union[str, bytes, os.PathLike]
  322. Path to the output file.
  323. figs : list[Figure]
  324. List of figures.
  326. Returns
  327. -------
  328. None.
  329. """
  331. # make sure that the output directory exists
  332. ensure_dir(fname)
  334. with PdfPages(fname) as pdf:
  335. for fig in figs:
  336. pdf.savefig(fig)
  339. @typechecked
  340. def snr_spectrum(psd: np.ndarray, noise_n_neighbor_freqs: int, noise_skip_neighbor_freqs: int = 0) -> np.ndarray:
  341. """Compute SNR spectrum from PSD spectrum using convolution.
  343. Parameters
  344. ----------
  345. psd : ndarray, shape ([n_trials, n_channels,] n_frequency_bins)
  346. Data object containing PSD values. Works with arrays as produced by
  347. MNE's PSD functions or channel/trial subsets.
  348. noise_n_neighbor_freqs : int
  349. Number of neighboring frequencies used to compute noise level.
  350. increment by one to add one frequency bin ON BOTH SIDES
  351. noise_skip_neighbor_freqs : int
  352. set this >=1 if you want to exclude the immediately neighboring
  353. frequency bins in noise level calculation
  355. Returns
  356. -------
  357. snr : ndarray, shape ([n_trials, n_channels,] n_frequency_bins)
  358. Array containing SNR for all epochs, channels, frequency bins.
  359. NaN for frequencies on the edges, that do not have enough neighbors on
  360. one side to calculate SNR.
  361. """
  362. # Construct a kernel that calculates the mean of the neighboring
  363. # frequencies
  364. averaging_kernel = np.concatenate(
  365. (
  366. np.ones(noise_n_neighbor_freqs),
  367. np.zeros(2 * noise_skip_neighbor_freqs + 1),
  368. np.ones(noise_n_neighbor_freqs),
  369. )
  370. )
  371. averaging_kernel /= averaging_kernel.sum()
  373. # Calculate the mean of the neighboring frequencies by convolving with the
  374. # averaging kernel.
  375. mean_noise = np.apply_along_axis(
  376. lambda psd_: np.convolve(psd_, averaging_kernel, mode="valid"), axis=-1, arr=psd
  377. )
  379. # The mean is not defined on the edges so we will pad it with nas. The
  380. # padding needs to be done for the last dimension only so we set it to
  381. # (0, 0) for the other ones.
  382. edge_width = noise_n_neighbor_freqs + noise_skip_neighbor_freqs
  383. pad_width = [(0, 0)] * (mean_noise.ndim - 1) + [(edge_width, edge_width)]
  384. mean_noise = np.pad(mean_noise, pad_width=pad_width,
  385. constant_values=np.nan)
  387. return psd / mean_noise
  390. @typechecked
  391. def px_to_degrees_of_visual_angle(
  392. pix: Union[float, np.ndarray],
  393. screen_width: float,
  394. screen_distance: float,
  395. screen_resolution_width: float,
  396. ) -> Union[float, np.ndarray]:
  397. """
  398. Convert pixels to degrees of visual angle.
  400. Parameters
  401. ----------
  402. pix : Union[float, np.ndarray]
  403. Pixels.
  404. screen_width : float
  405. Screen width in m.
  406. screen_distance : float
  407. Screen distance in m.
  408. screen_resolution_width : float
  409. Screen resolution width in pixels.
  411. Returns
  412. -------
  413. Union[float, np.ndarray]
  414. Degrees of visual angle.
  415. """
  417. return np.degrees(np.arctan2(pix * screen_width, screen_distance * screen_resolution_width))
  420. @typechecked
  421. def load_config(max_iter: int = 3) -> Dict:
  422. """
  423. First, this function is looking for config.yaml in the current directory. If no config.yaml is found, it will traverse the directory tree upwards until it finds a config.yaml or reaches max_iter.
  424. Then, it will look for config.local.yaml in the directory where config.yaml was found.
  425. Finally, it look for a config file called FILENAME.yaml in the current directory, where FILENAME is the name of the calling file.
  427. All config files are loaded and merged into a single dictionary, with the order of precedence being config.yaml < config.local.yaml < FILENAME.yaml.
  429. Parameters
  430. ----------
  431. max_iter : int, optional
  432. Maximum number of directories to traverse upwards. The default is 3.
  434. Returns
  435. -------
  436. Dict
  437. Configuration dictionary.
  439. """
  441. config = {}
  443. # try to find config.yaml
  444. config_fname = Path("config.yaml").resolve()
  445. i = 0
  446. while not config_fname.exists() and i < max_iter:
  447. config_fname = config_fname.parent / config_fname.name
  448. i += 1
  450. if config_fname.exists():
  451. with open(config_fname, "r") as f:
  452. config.update(safe_load(f))
  454. # try to find config.local.yaml
  455. config_local_fname = config_fname.parent / "config.local.yaml"
  456. if config_local_fname.exists():
  457. with open(config_local_fname, "r") as f:
  458. config.update(safe_load(f))
  460. # try to find the calling file's filename
  461. try:
  462. filename = inspect.stack()[1].filename
  463. assert filename.endswith(".py"), "Calling file must be a python file."
  464. config_fname = Path(filename).resolve().with_suffix(".yaml")
  466. with open(config_fname, "r") as f:
  467. config.update(safe_load(f))
  469. assert isinstance(config, dict)
  471. except:
  472. pass
  474. return config
  477. @typechecked
  478. def find_all_subjects_and_sessions(dir: Union[str, bytes, os.PathLike]) -> dict[str, list[str]]:
  479. """
  480. Find all subjects and sessions in a directory, assuming that the directory structure follows this general pattern:
  482. dir
  483. ├── sub-01
  484. │ ├── ses-01
  485. │-- sub-02
  486. │ ├── ses-01
  487. │ ├── ses-02
  490. Parameters
  491. ----------
  492. dir : Union[str, bytes, os.PathLike]
  493. Path to the directory.
  495. Returns
  496. -------
  497. dict[str, list[str]]
  498. Dictionary of subject/session combinations. The keys are the subjects, and the values are lists of sessions.
  499. """
  500. subjects = {}
  502. # use pathlib to traverse the directory tree
  503. for path in Path(dir).iterdir():
  504. if path.is_dir():
  505. # if we find a directory, check if it starts with "sub-"
  506. if path.name.startswith("sub-"):
  507. subject = path.name[4:]
  508. sessions = []
  510. # find all sessions in the directory
  511. for session_path in path.iterdir():
  512. if session_path.is_dir():
  513. if session_path.name.startswith("ses-"):
  514. sessions.append(session_path.name[4:])
  516. if len(sessions) > 0:
  517. subjects[subject] = sessions
  519. return subjects
  522. @typechecked
  523. def get_snr_spectrum(psd: np.ndarray, noise_n_neighbor_freqs: int, noise_skip_neighbor_freqs: int = 0) -> np.ndarray:
  524. """Compute SNR spectrum from PSD spectrum using convolution.
  526. Parameters
  527. ----------
  528. psd : ndarray, shape ([n_trials, n_channels,] n_frequency_bins)
  529. Data object containing PSD values. Works with arrays as produced by
  530. MNE's PSD functions or channel/trial subsets.
  531. noise_n_neighbor_freqs : int
  532. Number of neighboring frequencies used to compute noise level.
  533. increment by one to add one frequency bin ON BOTH SIDES
  534. noise_skip_neighbor_freqs : int
  535. set this >=1 if you want to exclude the immediately neighboring
  536. frequency bins in noise level calculation
  538. Returns
  539. -------
  540. snr : ndarray, shape ([n_trials, n_channels,] n_frequency_bins)
  541. Array containing SNR for all epochs, channels, frequency bins.
  542. NaN for frequencies on the edges, that do not have enough neighbors on
  543. one side to calculate SNR.
  544. """
  545. # Construct a kernel that calculates the mean of the neighboring
  546. # frequencies
  547. averaging_kernel = np.concatenate((
  548. np.ones(noise_n_neighbor_freqs),
  549. np.zeros(2 * noise_skip_neighbor_freqs + 1),
  550. np.ones(noise_n_neighbor_freqs)))
  551. averaging_kernel /= averaging_kernel.sum()
  553. # Calculate the mean of the neighboring frequencies by convolving with the
  554. # averaging kernel.
  555. mean_noise = np.apply_along_axis(
  556. lambda psd_: np.convolve(psd_, averaging_kernel, mode='valid'),
  557. axis=-1, arr=psd
  558. )
  560. # The mean is not defined on the edges so we will pad it with nas. The
  561. # padding needs to be done for the last dimension only so we set it to
  562. # (0, 0) for the other ones.
  563. edge_width = noise_n_neighbor_freqs + noise_skip_neighbor_freqs
  564. pad_width = [(0, 0)] * (mean_noise.ndim - 1) + [(edge_width, edge_width)]
  565. mean_noise = np.pad(
  566. mean_noise, pad_width=pad_width, constant_values=np.nan
  567. )
  569. return psd / mean_noise
  572. # def crop_edf_tmp(edf_file, *, new_start=None, new_stop=None, verbose=True):
  573. # """Crop an EDF file to desired start/stop times and save it to a temporary file.
  575. # Parameters
  576. # ----------
  577. # edf_file : str
  578. # The path to the EDF file.
  579. # new_start : datetime.datetime
  580. # The new start timestamp. Can be None to keep the original start time.
  581. # new_stop : datetime.datetime
  582. # The new stop timestamp. Can be None to keep the original stop time.
  583. # verbose : bool
  584. # If True (default), print some details about the original and cropped file.
  586. # Returns
  587. # -------
  588. # str
  589. # Path to the temporary file.
  590. # """
  592. # edf_file_p = Path(edf_file)
  595. # # create a temporary file
  596. # tmpfile = os.path.join(tmpdir, edf_file_p.name)
  598. # # crop the file
  599. # crop_edf(edf_file, new_file=tmpfile, new_start=new_start, new_stop=new_stop, verbose=verbose)
  601. # # return the temporary file
  602. # return tmpfile
  605. def crop_edf(edf_file, *, new_file=None, new_start=None, new_stop=None, write_full_datarecord=True,
  606. verbose=True):
  607. """Crop an EDF file to desired start/stop times.
  609. Parameters
  610. ----------
  611. edf_file : str
  612. The path to the EDF file.
  613. new_file : str | None
  614. The path to the new cropped file. If None (default), the input
  615. filename appended with '_cropped' is used.
  616. new_start : flaot | None
  617. The new start time in seconds. Can be None to keep the original start
  618. new_stop : float | None
  619. The new stop time in seconds. Can be None to keep the original stop
  620. write_full_datarecord : bool
  621. If True (default), write the full datarecord to the new file. If False,
  622. will pad the datarecord with zeros to the next full datarecord.
  624. Note that if True, the duration of the new file will be slightly longer than the specified duration (up to the length of one datarecord)
  625. Also, this will raise an error if the newly calculated end sample is after the end of the file.
  626. verbose : bool
  627. If True (default), print some details about the original and cropped file.
  628. """
  630. # Print some info
  631. print(f"Cropping {edf_file} to {new_start} - {new_stop}.")
  633. # Open the original EDF file
  634. edf = pyedflib.EdfReader(edf_file)
  635. signals_headers = edf.getSignalHeaders()
  636. header = edf.getHeader()
  638. # Define new start time
  639. if new_start is None:
  640. start_diff_seconds = 0
  641. else:
  642. start_diff_seconds = new_start
  644. # Define new stop time
  645. if new_stop is None:
  646. stop_diff_from_start = edf.getFileDuration()
  647. else:
  648. stop_diff_from_start = new_stop
  650. # if write_full_datarecord is True, we adjust the stop time to the next full datarecord
  651. if write_full_datarecord:
  652. # edf files are divided into datarecords and one can only write full datarecords
  653. # edf.datarecord_duration
  655. stop_diff_from_start = stop_diff_from_start - \
  656. ((stop_diff_from_start - start_diff_seconds) %
  657. edf.datarecord_duration) + edf.datarecord_duration
  659. print(
  660. f"Extending stop time to {stop_diff_from_start} to write full datarecord. New duration is {stop_diff_from_start - start_diff_seconds}.")
  662. # Crop each signal
  663. signals = []
  664. digital_min = []
  665. digital_max = []
  667. for i in range(len(edf.getSignalHeaders())):
  668. # Question: should we use `_get_sample_frequency` instead?
  669. sf = edf.getSampleFrequency(i)
  670. start_idx = int(start_diff_seconds * sf)
  671. stop_idx = int(stop_diff_from_start * sf)
  673. # We use digital=True in reading and writing to avoid precision loss
  674. signals.append(edf.readSignal(i, start=start_idx,
  675. n=stop_idx - start_idx, digital=True))
  676. # get digital min/max
  677. digital_min.append(signals_headers[i]['digital_min'])
  678. digital_max.append(signals_headers[i]['digital_max'])
  680. edf.close()
  682. # Update header startdate and save file
  683. header["startdate"] = edf.getStartdatetime(
  684. ) + timedelta(seconds=start_diff_seconds)
  686. if new_file is None:
  687. file, ext = os.path.splitext(edf_file)
  688. new_file = file + '_cropped' + ext
  690. write_edf(new_file, signals, signals_headers, header, digital=True)
  692. # Safety check: are we able to load the new EDF file?
  693. # Get new EDF start, stop and duration
  694. edf = pyedflib.EdfReader(new_file)
  695. start = edf.getStartdatetime()
  696. stop = start + timedelta(seconds=edf.getFileDuration())
  697. duration = stop - start
  698. edf.close()
  701. def find_bad_epochs(epochs: mne.Epochs, reject: dict[str, float], reject_by_annotation=False, verbose: bool = True) -> np.ndarray:
  702. """
  703. Find bad epochs based on peak-to-peak amplitude rejection thresholds. Return the drop log.
  705. Parameters
  706. ----------
  707. epochs : mne.Epochs
  708. Epochs.
  709. reject : dict[str, float]
  710. Rejection thresholds.
  711. verbose : bool, optional
  712. If True, print some details. The default is True.
  714. Returns
  715. -------
  716. tuple of tuples
  717. The drop log.
  718. """
  720. # copy epochs
  721. _epochs = deepcopy(epochs)
  723. # reject epochs
  724. _epochs.drop_bad(reject=reject, verbose=verbose,
  725. reject_by_annotation=reject_by_annotation)
  727. # get bad epochs indices
  728. return _epochs.drop_log

utils.py at commit 0ad609e, no license · at the source

Overview

Authors: Kim Eliane Stäubli1,2,3, Marc Pabst1,2,3, Roni O. Maimon-Mor1,2, Ana Catalina Rodriguez-Martinez1,3,4, H. Steven Scholte5, Mariya Moosajee1,3,6, Tessa Marlijn Dekker1,2,3
ORCID iDs: Kim Eliane Stäubli, Marc Pabst, Roni O. Maimon-Mor, Ana Catalina Rodriguez-Martinez, H. Steven Scholte, Mariya Moosajee, Tessa Marlijn Dekker
  1. Institute of Ophthalmology, University College London, London EC1V 9EL, UK
  2. Experimental Psychology, Division of Psychology and Language Sciences, University College London, London WC1H 0AP, UK
  3. Moorfields Eye Hospital NHS Foundation Trust, London EC1V 2PD, UK
  4. Great Ormond Street Hospital for Children NHS Foundation Trust, London WC1N 3JH, UK
  5. Department of Psychology, University of Amsterdam, 1018 WT Amsterdam, Netherlands
  6. The Francis Crick Institute, London NW1 1AT, UK
Institutions: Moorfields Eye Hospital NHS Foundation Trust (United Kingdom); University College London (United Kingdom); Great Ormond Street Hospital (United Kingdom); Great Ormond Street Hospital for Children NHS Foundation Trust (United Kingdom); University of Amsterdam (Netherlands); The Francis Crick Institute (United Kingdom)
Journal: Computational and structural biotechnology journal, volume 35, issue 1, article 0042
Dates: received 27 December 2025; accepted 16 March 2026; published online 30 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.34133/csbj.0042 · PMID 42078489 · PMCID PMC13132498 · OpenAlex W7137910620
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), other condition (population), clinical / translational (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Preprocessing, Physiology & signal measures
Journal subjects: General
Topic: Drug-Induced Ocular Toxicity (Ophthalmology, Medicine), according to OpenAlex
Funding: Santen; Wellcome Trust; Fight for Sight UK; Moorfields Eye Charity; National Institute for Health Research Biomedical Research Centre at Moorfields Eye Hospital NHS Foundation Trust and UCL Institute of Ophthalmology
Citations: cited by 1 paper (Europe PMC); 58 references in the paper

Abstract

Rapid advances in gene therapy are moving sight rescue treatments for inherited retinal diseases (IRDs) within reach, creating an urgent need to understand how these conditions affect neural signaling from the eye to the brain. However, capturing functional change across the diverse IRD sight-loss spectrum using a unified testing framework is challenging. Computational neuroimaging may help address this gap by exploiting known principles of visual-system tuning to derive more sensitive and computationally meaningful markers of visual function. This is particularly important in CRB1 retinopathy, an IRD with a strikingly wide phenotype range, where neural impacts across the full disease spectrum are not yet characterized. To investigate the functional impact of CRB1 retinopathy, we recorded steady-state visual evoked potentials (ssVEPs) in 72 eyes from 18 patients and 18 sighted controls using a patient-friendly, large-field protocol embedding phase-reversing sinusoidal gratings and full-screen flashes into age-appropriate videos. Fitting these data with neural tuning functions revealed significant ssVEP attenuation in patients, with the greatest reductions in those with generalized retinal degeneration, alongside shifts in spatial-frequency tuning toward lower frequencies. Our results show that with appropriate stimulus selection, ssVEPs offer a reliable response-free measure of visual function that correlates well with behavioral vision assessments and discriminates between CRB1 subgroups, with the optimally sensitive stimulus for detecting functional variation varying with the level of vision. Computational electroencephalogram-based neuroimaging thus provides quantitative insights across the wide spectrum of CRB1 pathology and represents a valuable complementary tool for evaluating disease progression and treatment outcomes in CRB1 retinopathy and related IRDs.

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

ChildVisionLab/crb1_ssvep_workflow

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 0ad609e477d51491b49bf5e2a9895b0ec6182613, 16 March 2026
Languages: Python (22), R (7), Jupyter (6), Shell (1), JavaScript (1)
Size: 50 files, 37 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, environment (01_eeg_preprocessing/environment.yml, 01_eeg_preprocessing/pyproject.toml, 02_data_analysis/src/environment.yaml), 12 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: pandas (24 files), NumPy (21 files), Matplotlib (16 files), MNE-Python (13 files), MNE-BIDS (12 files), seaborn (8 files), Plotly (7 files), SciPy (6 files), tidyverse (6 files), lme4 (5 files), lmerTest (5 files), psych (5 files), car (4 files), emmeans (4 files), scikit-learn (4 files), easystats (2 files), Pingouin (2 files), ggplot2 (1 file), Pillow (1 file), statsmodels (1 file), SymPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
38 files
At the source: github.com/ChildVisionLab/crb1_ssvep_workflow

ChildVisionLab/EEG_Stimulation_CRB1

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 1ef24e7daaae83e8e743a689fa9a35fa124b735b, 6 March 2026
Languages: Python (7)
Size: 10 files, 7 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: license file, environment (pixi.toml)
Not found: README, CITATION.cff, tests, continuous integration, documentation
Tools: PsychoPy (5 files), NumPy (3 files), MNE-BIDS (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
8 files
At the source: github.com/ChildVisionLab/EEG_Stimulation_CRB1

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

Tracing map

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

What the map holds:

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

Due to the sensitive nature of the data, raw EEG data cannot be shared, but fully anonymized preprocessed data are available on Zenodo (https://doi.org/10.5281/zenodo.18956093). Code to reproduce the results reported in this paper are available at https://github.com/ChildVisionLab/crb1_ssvep_workflow, and code used for stimulus presentation are available at https://github.com/ChildVisionLab/EEG_Stimulation_CRB1.

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

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 5 funders, 45 references.

Cite

This paper

Stäubli, K. E., Pabst, M., O. Maimon-Mor, R., Rodriguez-Martinez, A. C., Scholte, H. S., Moosajee, M., & Dekker, T. M. (2026). Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials. Computational and structural biotechnology journal, 35(1), 0042. https://doi.org/10.34133/csbj.0042

BibTeX

@article{staubli2026using,
author = {Stäubli, Kim Eliane and Pabst, Marc and O. Maimon-Mor, Roni and Rodriguez-Martinez, Ana Catalina and Scholte, H. Steven and Moosajee, Mariya and Dekker, Tessa Marlijn},
title = {{Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to \&lt;i\&gt;CRB1\&lt;/i\&gt;: Implications for Clinical Trials}},
journal = {Computational and structural biotechnology journal},
year = {2026},
month = apr,
volume = {35},
number = {1},
pages = {0042},
publisher = {AAAS Science Partner Journal Program},
issn = {2001-0370},
doi = {10.34133/csbj.0042},
url = {https://doi.org/10.34133/csbj.0042},
pmid = {42078489},
pmcid = {PMC13132498}
}

RIS

TY - JOUR
AU - Stäubli, Kim Eliane
AU - Pabst, Marc
AU - O. Maimon-Mor, Roni
AU - Rodriguez-Martinez, Ana Catalina
AU - Scholte, H. Steven
AU - Moosajee, Mariya
AU - Dekker, Tessa Marlijn
TI - Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials
T2 - Computational and structural biotechnology journal
J2 - Comput Struct Biotechnol J
PY - 2026
DA - 2026/04/30
VL - 35
IS - 1
SP - 0042
SN - 2001-0370
PB - AAAS Science Partner Journal Program
DO - 10.34133/csbj.0042
UR - https://doi.org/10.34133/csbj.0042
LA - en
ER -

CSL-JSON

{
"id": "10.34133/csbj.0042",
"type": "article-journal",
"title": "Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials",
"container-title": "Computational and structural biotechnology journal",
"author": [
{
"family": "Stäubli",
"given": "Kim Eliane"
},
{
"family": "Pabst",
"given": "Marc"
},
{
"family": "O. Maimon-Mor",
"given": "Roni"
},
{
"family": "Rodriguez-Martinez",
"given": "Ana Catalina"
},
{
"family": "Scholte",
"given": "H. Steven"
},
{
"family": "Moosajee",
"given": "Mariya"
},
{
"family": "Dekker",
"given": "Tessa Marlijn"
}
],
"container-title-short": "Comput Struct Biotechnol J",
"volume": "35",
"issue": "1",
"page": "0042",
"DOI": "10.34133/csbj.0042",
"PMID": "42078489",
"PMCID": "PMC13132498",
"ISSN": "2001-0370",
"publisher": "AAAS Science Partner Journal Program",
"URL": "https://doi.org/10.34133/csbj.0042",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
30
]
]
}
}

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/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: MNE-BIDS, Pingouin, easystats, 13 other tools, EEG
[2] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: MNE-BIDS, Pingouin, easystats, 13 other tools
[3] 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: MNE-BIDS, Pingouin, easystats, 13 other tools
[4] 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: MNE-BIDS, psych, easystats, 12 other tools, EEG
[5] doi:10.1093/braincomms/fcag176 [code]
Tau topography subtypes account for clinical heterogeneity and longitudinal trajectories in early-onset Alzheimer's disease.
Journal: Brain communications
In common: easystats, car, emmeans, 13 other tools, clinical / translational
[6] doi:10.1162/imag.a.1321 [code]
Phase similarity between similar objects indicates representational merging across retrieval training but not sleep.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Pingouin, easystats, car, 12 other tools, EEG
[7] doi:10.1093/cercor/bhag077 [code]
The longitudinal development of intrinsic timescales in infancy and their relation to alpha brain rhythm.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: Pingouin, psych, easystats, 12 other tools, EEG
[8] doi:10.1162/imag.a.105 [code]
Right posterior theta reflects human parahippocampal phase resetting by salient cues during goal-directed navigation
Journal: n/a
In common: Pingouin, psych, car, 11 other tools, EEG
[9] doi:10.1038/s41467-026-74824-0 [code]
Learning regularities in noise engages both neural predictive activity and representational changes.
Journal: Nature communications
In common: MNE-BIDS, Pingouin, easystats, 10 other tools
[10] doi:10.1016/j.nicl.2026.104012 [code]
Structural-functional multilayer brain network properties and outcome of combined repetitive transcranial magnetic stimulation and psychotherapy for obsessive-compulsive disorder.
Journal: NeuroImage. Clinical
In common: Pingouin, psych, car, 11 other tools, other condition

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.