OSCR

An enteric neuron ionotropic receptor regulates salt stress resistance.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 944 lines · 40 KB · MIT

  1. #!/usr/bin/env python3
  2. #######################################################################
  3. # Kymograph Generation for C. elegans Pharyngeal Pumping Analysis
  4. #
  5. # This script processes video recordings of C. elegans to generate kymographs
  6. # that visualize pharyngeal pumping behavior over time. The analysis pipeline:
  7. #
  8. # 1. Loads behavior recordings from HDF5 files
  9. # 2. Segments worms from background using image processing
  10. # 3. Extracts skeleton centerlines using Tierpsy tracker
  11. # 4. Creates kymographs showing intensity changes along the body
  12. # 5. Generates quality control videos with skeleton overlays
  13. #
  14. # Key outputs:
  15. # - Kymograph images showing pumping patterns
  16. # - Processed videos for quality control
  17. # - Numerical data for further analysis
  18. #######################################################################
  20. # Modules
  21. import os # File and folder path handling
  22. import gc # Garbage collection for memory management
  23. import datetime # Timestamp generation
  24. import numpy as np # Numerical computing and array operations
  25. import matplotlib.pyplot as plt # Plotting and image generation
  26. from scipy.io import savemat # MATLAB file export
  28. # Tierpsy Tracker - C. elegans computer vision library
  29. # https://github.com/SinRas/tierpsy-tracker
  30. import tierpsy
  31. from tierpsy.analysis.ske_create.getSkeletonsTables import getWormMask, getSkeleton
  33. # Custom utilities for data processing
  34. from utils import *
  35. # Import configuration parameters
  36. from config import *
  39. #######################################################################
  40. # Computer Vision Functions
  41. #
  42. # These functions handle the image processing pipeline for worm detection
  43. # and skeleton extraction. They work together to convert raw video frames
  44. # into structured data suitable for behavioral analysis.
  45. #######################################################################
  47. def create_foreground_mask(img_beh, threshold_foreground=130, threshold_area_min_object=100, threshold_area_max_object=500_000):
  48. """
  49. Create a binary mask identifying worm pixels in the image.
  51. This function segments the worm from the background by:
  52. 1. Applying intensity thresholding to find dark objects
  53. 2. Filtering by object size to remove debris and artifacts
  55. Args:
  56. img_beh: Input grayscale image (numpy array)
  57. threshold_foreground: Intensity threshold for worm detection (0-255)
  58. threshold_area_min_object: Minimum object size in pixels
  59. threshold_area_max_object: Maximum object size in pixels
  61. Returns:
  62. Binary mask where True indicates worm pixels
  63. """
  64. # Apply multi-scale thresholding to handle varying image quality
  65. img_beh_masked = (cv.medianBlur(img_beh, 11) < threshold_foreground) | \
  66. (cv.medianBlur(img_beh, 3) < threshold_foreground) | \
  67. (img_beh < threshold_foreground)
  69. # Remove objects that are too small or too large (debris, artifacts)
  70. n_labels, labels, stats, centroids = cv.connectedComponentsWithStats(img_beh_masked.astype(np.uint8))
  71. img_beh_masked &= False # Reset mask
  73. # Keep only objects within size constraints
  74. for label, area in enumerate(stats[:, -1]):
  75. if label == 0 or area < threshold_area_min_object or area > threshold_area_max_object:
  76. continue
  77. img_beh_masked |= labels == label
  78. # Return
  79. return img_beh_masked
  80. def extract_worm_mask(img_mask, coords_center=None, size_close=11):
  81. """
  82. Extract the worm mask by selecting the largest connected component and filling gaps.
  84. This function refines the foreground mask by:
  85. 1. Finding the object closest to the expected worm position
  86. 2. Filling gaps in the worm outline using morphological operations
  87. 3. Ensuring the mask represents a single, connected worm
  89. Args:
  90. img_mask: Binary foreground mask from create_foreground_mask()
  91. coords_center: Expected worm position (None = use image center)
  92. size_close: Size of morphological closing kernel
  94. Returns:
  95. Refined binary mask representing the worm
  96. """
  97. if coords_center is None:
  98. coords_center = np.array(img_mask.shape, dtype=np.float32) / 2
  100. # Find all connected components in the mask
  101. n_labels, labels, stats, centroids = cv.connectedComponentsWithStats(img_mask.astype(np.uint8))
  103. # Handle case where no objects are found
  104. if n_labels <= 1:
  105. return np.zeros_like(img_mask, dtype=np.bool_)
  107. # Select the object closest to the expected center position
  108. dists = np.linalg.norm(centroids - coords_center[np.newaxis, :], axis=1)
  109. label_closest_center = 1 + np.argmin(dists[1:])
  110. worm_mask = labels == label_closest_center
  112. # Fill gaps in the worm outline using morphological closing
  113. worm_mask = cv.morphologyEx(
  114. worm_mask.astype(np.uint8),
  115. cv.MORPH_CLOSE,
  116. cv.getStructuringElement(cv.MORPH_ELLIPSE, (size_close, size_close))
  117. ) > 0
  119. # Fill interior regions by inverting and finding background
  120. n_labels, labels, stats, centroids = cv.connectedComponentsWithStats((~worm_mask).astype(np.uint8))
  121. label_all_background = 1 + np.argmax(stats[1:, -1])
  122. worm_mask = labels != label_all_background
  123. # Return
  124. return worm_mask
  125. def convert_mask_for_tierpsy(worm_mask):
  126. """
  127. Convert binary mask to format expected by Tierpsy skeleton extraction.
  129. Tierpsy expects specific intensity values:
  130. - Background: 255 (white)
  131. - Threshold: 110 (splits background from worm)
  132. - Worm: 55 (dark gray, or any value below 110)
  134. Args:
  135. worm_mask: Binary mask where True = worm pixels
  137. Returns:
  138. Grayscale image with proper intensity values for Tierpsy
  139. """
  140. img_tierpsy = (worm_mask == 0).astype(np.uint8) * 200 # Background = 200
  141. img_tierpsy += 55 # Worm = 55, Background = 255
  142. return img_tierpsy
  143. def extract_skeleton(worm_mask, skeleton_prev=np.zeros(0), n_skeleton_segments=101):
  144. """
  145. Extract worm skeleton using Tierpsy computer vision library.
  147. This function uses Tierpsy's algorithms to find the centerline of the worm,
  148. which is essential for creating kymographs.
  150. Args:
  151. worm_mask: Binary mask representing the worm
  152. skeleton_prev: Previous skeleton for temporal consistency (optional)
  153. n_skeleton_segments: Number of points along the skeleton
  155. Returns:
  156. Array of skeleton points (x, y coordinates)
  157. """
  158. # Convert mask to Tierpsy format
  159. worm_tierpsy = convert_mask_for_tierpsy(worm_mask)
  161. # Extract worm contour using Tierpsy
  162. _, worm_cnt, _ = getWormMask(
  163. worm_img=worm_tierpsy,
  164. threshold=110, # Don't change it, this is paired with `img_mask_to_tierpsy`
  165. strel_size=11, # Hard coded in Tierpsy
  166. min_blob_area=TIERPSY_MIN_BLOB_AREA, # Change if you need to find skeleton for a very tiny worm, which should not be the case!
  167. is_light_background=TIERPSY_IS_LIGHT_BACKGROUND
  168. )
  170. # Extract skeleton from contour
  171. output = getSkeleton(
  172. worm_cnt=worm_cnt,
  173. prev_skeleton=skeleton_prev,
  174. resampling_N=n_skeleton_segments
  175. )
  176. skeleton, ske_len, cnt_side1, cnt_side2, cnt_widths, cnt_area = output
  177. # Return
  178. return skeleton
  180. #######################################################################
  181. # Time Series Processing Functions
  182. #
  183. # These functions handle temporal smoothing of skeleton data to reduce
  184. # noise and improve the quality of kymograph generation. They implement
  185. # different types of moving averages for different analysis needs.
  186. #######################################################################
  188. def moving_average_causal(arr, k, dtype=np.float32):
  189. """
  190. Apply causal (past-only) moving average to time series data.
  192. This function smooths data using only past values, making it suitable
  193. for real-time analysis where future data is not available.
  195. Args:
  196. arr: Input time series array
  197. k: Window size for averaging
  198. dtype: Output data type
  200. Returns:
  201. Smoothed time series array
  202. """
  203. if k <= 1:
  204. return arr.copy()
  205. if np.isnan(arr[0]) or np.isnan(arr[-1]):
  206. il = 0
  207. while il < len(arr) and np.isnan(arr[il]):
  208. il += 1
  209. ir = len(arr)-1
  210. while ir >= 0 and np.isnan(arr[ir]):
  211. ir -= 1
  212. ir += 1
  213. assert il < ir, "Please don't test me on all edge cases :)) give me a better array! :grin: (array is all NaNs)"
  214. result = np.zeros_like(arr) * np.nan
  215. result[il:ir] = moving_average_causal( arr[il:ir], k )
  216. return result
  217. # Rolling counts
  218. w = k+1
  219. arr_cumsum = np.nancumsum( arr, axis=0 )
  220. ns_cumsum = np.cumsum( ~np.isnan(arr), axis=0 )
  221. result = np.zeros_like(arr_cumsum, dtype=dtype) * np.nan
  222. # Beginning
  223. result[:w] = arr_cumsum[:w] / ns_cumsum[:w]
  224. # Rest
  225. result[w:] = (arr_cumsum[w:] - arr_cumsum[:-w]) / np.maximum(ns_cumsum[w:] - ns_cumsum[:-w], 1)
  226. # NaNs
  227. _indices = w + np.where( ns_cumsum[w:] == ns_cumsum[:-w] )[0]
  228. result[_indices] = np.nan
  229. # Return
  230. return result
  231. def moving_average_symmetric(arr, k, dtype=np.float32):
  232. """
  233. Apply symmetric (past and future) moving average to time series data.
  235. This function smooths data using both past and future values, providing
  236. better smoothing but requiring the entire time series to be available.
  238. Args:
  239. arr: Input time series array
  240. k: Window size for averaging
  241. dtype: Output data type
  243. Returns:
  244. Smoothed time series array
  245. """
  246. if k <= 1:
  247. return arr.astype(dtype)
  248. return (moving_average_causal(arr, k, dtype=dtype) * (k+1) +
  249. moving_average_causal(arr[::-1], k-1, dtype=dtype)[::-1] * k) / (2*k+1)
  251. #######################################################################
  252. # Skeleton Processing and Kymograph Generation
  253. #
  254. # These functions handle the geometric processing of skeleton data and
  255. # the creation of kymographs that visualize intensity changes along the
  256. # worm's body over time.
  257. #######################################################################
  259. from scipy.interpolate import make_interp_spline
  261. def smooth_skeleton(arr2d, stride=5, k=3):
  262. """
  263. Smooth skeleton coordinates using cubic spline interpolation.
  265. This function reduces noise in skeleton tracking by fitting smooth
  266. curves through the skeleton points.
  268. Args:
  269. arr2d: 2D array of skeleton coordinates (time, points, x/y)
  270. stride: Sampling interval for spline fitting
  271. k: Spline order (3 = cubic)
  273. Returns:
  274. Smoothed skeleton coordinates
  275. """
  276. ts = np.arange(len(arr2d))
  277. spl = make_interp_spline(ts[::stride], arr2d[::stride], k=k)
  278. return spl(ts)
  279. def interpolate_skeleton(coords, dists_to_interpolate, k=3):
  280. """
  281. Interpolate skeleton points at specific distances from the head.
  283. This function creates a standardized skeleton representation by
  284. sampling points at regular intervals along the worm's length.
  286. Args:
  287. coords: Skeleton coordinates (points, x/y)
  288. dists_to_interpolate: Target distances from head (in pixels)
  289. k: Spline order for interpolation
  291. Returns:
  292. Interpolated skeleton coordinates at specified distances
  293. """
  294. # Calculate cumulative distances along skeleton
  295. dists = np.zeros(len(coords))
  296. dists[1:] = np.cumsum(np.linalg.norm(np.diff(coords, axis=0), axis=1))
  298. # Interpolate at target distances
  299. spl = make_interp_spline(dists, coords, k=k)
  300. return spl(dists_to_interpolate)
  301. def compute_skeleton_normals(skeleton, normal_factors=np.arange(-5.0, 6.0, 1.0)):
  302. """
  303. Create perpendicular lines (normals) extending from skeleton points.
  305. These normals are used to measure intensity profiles
  306. across the body for kymograph generation.
  308. Args:
  309. skeleton: Skeleton coordinates (points, x/y)
  310. normal_factors: Distances along normals (negative = left, positive = right)
  312. Returns:
  313. 3D array of normal line coordinates (midpoints, x/y, normal_points)
  314. """
  315. # Calculate midpoints between consecutive skeleton points
  316. skeleton_mids = (skeleton[:-1] + skeleton[1:]) / 2
  318. # Calculate normal vectors (perpendicular to skeleton direction)
  319. diffs = np.diff(skeleton, axis=0)
  320. dists = np.linalg.norm(diffs, axis=1)
  321. normals = diffs[:, ::-1] / dists[:, np.newaxis] # Rotate 90 degrees
  322. normals[:, 0] *= -1 # Flip x-component for correct orientation
  324. # Create normal lines extending from midpoints
  325. skeleton_mids_normals = skeleton_mids[:, :, np.newaxis] + \
  326. (normals[:, :, np.newaxis] * normal_factors[np.newaxis, np.newaxis, :])
  328. return skeleton_mids_normals
  330. #######################################################################
  331. # Main Kymograph Processing Functions
  332. #
  333. # These functions process a segment of video data to generate kymographs
  334. # and quality control videos. They handle the complete pipeline from
  335. # raw video frames to kymograph images.
  336. #######################################################################
  338. def load_and_align_kymograph(fp_npz, scale_roll=1.0, il=130, ir=200):
  339. """
  340. Load kymograph data and align it to compensate for worm movement.
  342. This function addresses the challenge that worms can move during recording,
  343. causing the pharynx to shift position in the kymograph. Alignment is done
  344. by rolling the kymograph along the normal lines.
  346. Args:
  347. fp_npz: Path to NPZ file containing kymograph data
  348. scale_roll: Scaling factor for alignment correction
  349. il: Left boundary of analysis region (pixels from head)
  350. ir: Right boundary of analysis region (pixels from head)
  352. Returns:
  353. Tuple of (original_kymograph, aligned_kymograph)
  354. """
  355. # Load
  356. with np.load(fp_npz) as in_file:
  357. data = {
  358. key: in_file[key] for key in in_file.keys()
  359. }
  360. # Load or average
  361. intensities_skeleton_normals_avg = np.nanmean(
  362. data['intensities_skeleton_normals_full'][:, :, 15:46],
  363. axis=-1
  364. ) if 'intensities_skeleton_normals_full' in data else data['kymograph_skeleton_normals'].copy()
  365. # Find the gut boundary shifts
  366. weights = intensities_skeleton_normals_avg[:,il:ir]
  367. center_of_mass = np.nansum(
  368. weights * np.arange(ir-il)[np.newaxis,:], axis=1
  369. ) / np.nansum( weights, axis=1 )
  370. dindex_center_of_mass = np.round(
  371. (center_of_mass - np.nanmedian(center_of_mass))*scale_roll,
  372. 0
  373. ).astype(np.int64)
  374. # Rolled
  375. intensities_skeleton_normals_avg_rolled = intensities_skeleton_normals_avg.copy()
  376. for idx, k in enumerate(dindex_center_of_mass):
  377. if np.isnan(k) or np.isinf(k) or k == 0:
  378. continue
  379. intensities_skeleton_normals_avg_rolled[idx] = np.roll(intensities_skeleton_normals_avg_rolled[idx], k)
  380. # Return
  381. return intensities_skeleton_normals_avg, intensities_skeleton_normals_avg_rolled
  383. def process_kymograph_segment(idx_start, idx_end, indices_skeleton_reverse=set(), worm_id=None, condition=None, strain=None):
  384. """
  385. Process a video segment to generate kymographs and quality control videos.
  387. This function performs the complete analysis pipeline:
  388. 1. Creates foreground mask videos
  389. 2. Extracts worm masks and skeleton overlays
  390. 3. Generates kymographs showing intensity changes over time
  391. 4. Saves all data in multiple formats (NPZ, MAT, PNG)
  393. Args:
  394. idx_start: Starting frame index for processing
  395. idx_end: Ending frame index for processing
  396. indices_skeleton_reverse: Set of frame indices where skeleton orientation should be reversed
  397. """
  398. # Recording and writing parameters
  399. INDEX_START = idx_start
  400. INDICES_TO_CONSIDER = np.arange(idx_start, idx_end, 1)
  401. NT = len(INDICES_TO_CONSIDER)
  402. _PREFIX = f"{worm_id}_{condition}_{strain}_pumping_{str(idx_start).zfill(8)}_{str(idx_end).zfill(8)}_"
  403. FP_WRITE_VIDEO_FOREGROUND = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}movie_foreground.mp4" ) # Path to the video file to write masked foreground
  404. FP_WRITE_VIDEO_WORMMASK = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}movie_worm_mask.mp4" ) # Path to the video file to write worm mask video
  405. FP_WRITE_VIDEO_WORMSKELETON = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}movie_worm_skeleton.mp4" ) # Path to the video file to write worm mask video
  406. FP_WRITE_IMAGE_KYMOGRAPH = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_only_center.png" ) # Path to the video file to write worm mask video
  407. FP_WRITE_IMAGE_KYMOGRAPH_SCALED = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_only_center_scaled.png" ) # Path to the video file to write worm mask video
  408. FP_WRITE_IMAGE_KYMOGRAPH_NORMALS = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_normals.png" ) # Path to the video file to write worm mask video
  409. FP_WRITE_IMAGE_KYMOGRAPH_NORMALS_SCALED = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_normals_scaled.png" ) # Path to the video file to write worm mask video
  410. FP_WRITE_NPZ_KYMOGRAPH_ALL = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_all.npz" ) # Path to all the data for the kymographs, e.g. timestamps and distances in `um`
  411. FP_WRITE_MAT_KYMOGRAPH_ALL = os.path.join( FP_PUMPING_EXTRACTS, f"{_PREFIX}kymograph_all.mat" ) # Path to all the data for the kymographs, e.g. timestamps and distances in `um`
  412. # 1) Make foreground mask video
  413. # Add frame index and actual FPS
  414. # series_beh = SerializeDatas([imgs.copy()])
  415. ## Mask images (lazy calculation -> nothing is calculated until writing it to file)
  416. def do_mask(img):
  417. img_mask = create_foreground_mask(img, threshold_foreground=MASK_THRESHOLD_FOREGROUND, threshold_area_min_object=MASK_AREA_MIN_OBJECT, threshold_area_max_object=MASK_AREA_MAX_OBJECT)
  418. return img_mask.astype(np.uint8)
  419. series_to_write = ImgToProcess(series_beh, fn_process=do_mask, rescale=True)
  420. ## White color
  421. series_to_write = AddFrameIndicesTexts(
  422. series_to_write,
  423. texts=texts,
  424. textOrigin=TEXT_ORIGIN_WHITE, color=TEXT_COLOR_WHITE
  425. )
  426. ## Black color -> for very bright images
  427. series_to_write = AddFrameIndicesTexts(
  428. series_to_write,
  429. texts=texts,
  430. textOrigin=TEXT_ORIGIN_BLACK, color=TEXT_COLOR_BLACK
  431. )
  432. ## Slice specific range
  433. series_to_write = ReIndexData(
  434. series_to_write,
  435. indices_new=INDICES_TO_CONSIDER
  436. )
  437. write_video(
  438. series_to_write,
  439. fp=FP_WRITE_VIDEO_FOREGROUND,
  440. fps=FRAMES_PER_SECOND,
  441. verbose=True
  442. )
  443. # 2) Find worm mask
  444. # Add frame index and actual FPS
  445. # series_beh = SerializeDatas([imgs.copy()])
  446. ## Find worm mask
  447. def do_mask(img):
  448. img_mask = create_foreground_mask(img, threshold_foreground=MASK_THRESHOLD_FOREGROUND, threshold_area_min_object=MASK_AREA_MIN_OBJECT, threshold_area_max_object=MASK_AREA_MAX_OBJECT)
  449. worm_mask = extract_worm_mask(img_mask, coords_center=WORM_CENTER_ESTIMATE, size_close=WORM_SIZE_CLOSE)
  450. return worm_mask.astype(np.uint8)
  451. series_to_write = ImgToProcess(series_beh, fn_process=do_mask, rescale=True)
  452. ## White color
  453. series_to_write = AddFrameIndicesTexts(
  454. series_to_write,
  455. texts=texts,
  456. textOrigin=TEXT_ORIGIN_WHITE, color=TEXT_COLOR_WHITE
  457. )
  458. ## Black color -> for very bright images
  459. series_to_write = AddFrameIndicesTexts(
  460. series_to_write,
  461. texts=texts,
  462. textOrigin=TEXT_ORIGIN_BLACK, color=TEXT_COLOR_BLACK
  463. )
  464. ## Slice specific range
  465. series_to_write = ReIndexData(
  466. series_to_write,
  467. indices_new=INDICES_TO_CONSIDER
  468. )
  469. write_video(
  470. series_to_write,
  471. fp=FP_WRITE_VIDEO_WORMMASK,
  472. fps=FRAMES_PER_SECOND,
  473. verbose=True
  474. )
  475. # 3) Find skeleton and video from it
  476. # Add frame index and actual FPS
  477. # series_beh = SerializeDatas([imgs.copy()])
  478. ## Find worm mask
  479. def do_mask(img, idx_frame):
  480. # These non-local variables are used: idx_start, infos
  481. # Get skeleton
  482. idx_skeleton = idx_frame - idx_start if idx_frame >= idx_start else 0 # Technical due to definition of class `ImgToProcessIndexed`
  483. skeleton = infos['skeleton_smooth'][idx_skeleton]
  484. # Overlay image
  485. img_overlayed = cv.polylines( img.astype(np.uint8), [ skeleton.astype(np.int32)[:,np.newaxis,:] ], False, SKELETON_LINE_COLOR, SKELETON_LINE_WIDTH ) # Aesthetics: width and color of the skeleton
  486. # Head part
  487. img_overlayed = cv.polylines( img_overlayed, [ skeleton.astype(np.int32)[:SKELETON_HEAD_POINTS,np.newaxis,:] ], False, SKELETON_HEAD_LINE_COLOR, SKELETON_HEAD_LINE_WIDTH ) # Aesthetics: width and color of the skeleton
  488. return img_overlayed
  489. # Find skeleton
  490. infos = {
  491. 'indices': INDICES_TO_CONSIDER,
  492. 'skeleton': np.zeros((NT, SKELETON_N_SEGMENTS, 2), dtype=np.float64)*np.nan,
  493. }
  494. for idx, idx_frame in enumerate(tqdm(INDICES_TO_CONSIDER)):
  495. # Load
  496. img = series_beh[idx_frame]
  497. # Mask
  498. img_mask = create_foreground_mask(img, threshold_foreground=MASK_THRESHOLD_FOREGROUND, threshold_area_min_object=MASK_AREA_MIN_OBJECT, threshold_area_max_object=MASK_AREA_MAX_OBJECT)
  499. worm_mask = extract_worm_mask(img_mask, coords_center=WORM_CENTER_ESTIMATE, size_close=WORM_SIZE_CLOSE)
  500. # Skeleton
  501. skeleton_prev = np.zeros(0) if idx == 0 or np.any(np.isnan(infos['skeleton'][idx-1])) else infos['skeleton'][idx-1] # Use last skeleton if it was found, to re-orient and keep orientation consistency
  502. skeleton = extract_skeleton(
  503. worm_mask,
  504. skeleton_prev=skeleton_prev,
  505. n_skeleton_segments=SKELETON_N_SEGMENTS
  506. )
  507. ## Reverse initial skeleton
  508. if idx_frame in indices_skeleton_reverse:
  509. print(f"*** skeleton reversed at {idx_frame}")
  510. skeleton = skeleton[::-1]
  511. if len(skeleton) == 0:
  512. continue
  513. # Intensities
  514. infos['skeleton'][idx] = skeleton
  515. # Smooth Skeletons temporaly
  516. infos['skeleton_smooth'] = infos['skeleton'].copy()
  517. infos['skeleton_smooth'][1:] += infos['skeleton'][:-1]
  518. infos['skeleton_smooth'][:-1] += infos['skeleton'][1:]
  519. infos['skeleton_smooth'][:1] /= 2
  520. infos['skeleton_smooth'][1:-1] /= 3
  521. infos['skeleton_smooth'][-1:] /= 2
  522. # Write video
  523. series_to_write = ImgToProcessIndexed(series_beh, fn_process=do_mask, rescale=True)
  524. ## White color
  525. series_to_write = AddFrameIndicesTexts(
  526. series_to_write,
  527. texts=texts,
  528. textOrigin=TEXT_ORIGIN_WHITE, color=TEXT_COLOR_WHITE
  529. )
  530. ## Black color -> for very bright images
  531. series_to_write = AddFrameIndicesTexts(
  532. series_to_write,
  533. texts=texts,
  534. textOrigin=TEXT_ORIGIN_BLACK, color=TEXT_COLOR_BLACK
  535. )
  536. ## Slice specific range
  537. series_to_write = ReIndexData(
  538. series_to_write,
  539. indices_new=INDICES_TO_CONSIDER
  540. )
  541. write_video(
  542. series_to_write,
  543. fp=FP_WRITE_VIDEO_WORMSKELETON,
  544. fps=FRAMES_PER_SECOND,
  545. verbose=True
  546. )
  547. # 4) Create the kymograph
  548. # Interpolated
  549. dists_to_interpolate_px = SKELETON_INTENSITY_STEPS_UM / UM_PER_PIXEL
  550. _n = len(dists_to_interpolate_px)
  551. infos['skeleton_smooth_interp'] = infos['skeleton_smooth'].copy()
  552. infos['skeleton_smooth_interp_um'] = np.zeros((NT, _n, 2))*np.nan
  553. infos['skeleton_smooth_interp_um_normals'] = np.zeros((NT, _n, 2))*np.nan
  554. infos['intensities_skeleton'] = np.zeros((NT, _n))*np.nan
  555. infos['intensities_skeleton_normals'] = np.zeros((NT, _n-1))*np.nan
  556. infos['intensities_skeleton_normals_full'] = np.zeros((NT, _n-1, N_SKELETON_NORMALS_HALF_LENGTH_PIXELS))*np.nan
  557. infos['widths_skeleton_normals'] = np.zeros((NT, _n-1))*np.nan
  558. # Load intensities along lines
  559. for idx, idx_frame in enumerate(tqdm(infos['indices'])):
  560. # Skeleton Smoothed
  561. skeleton = infos['skeleton_smooth'][idx]
  562. if np.any(np.isnan(skeleton)):
  563. continue
  564. # Smooth spatially
  565. skeleton_interp = smooth_skeleton( skeleton, stride=5, k=3 )
  566. skeleton_interp_um = interpolate_skeleton(skeleton_interp, dists_to_interpolate_px, k=3 )
  567. skeleton_interp_um_normals = compute_skeleton_normals(
  568. skeleton_interp_um,
  569. normal_factors=np.arange(-SKELETON_NORMALS_HALF_LENGTH_PIXELS, SKELETON_NORMALS_HALF_LENGTH_PIXELS+1).astype(np.float32)
  570. )
  571. skeleton_interp_um_normals = np.minimum(
  572. np.maximum(
  573. skeleton_interp_um_normals, 0
  574. ),
  575. NX-1
  576. ).astype(np.int64)
  577. infos['skeleton_smooth_interp'][idx] = skeleton_interp
  578. infos['skeleton_smooth_interp_um'][idx] = skeleton_interp_um
  579. skeleton_int = np.minimum(
  580. np.maximum(
  581. skeleton_interp_um, 0
  582. ),
  583. NX-1
  584. ).astype(np.int64)
  585. # Load
  586. img = series_beh[idx_frame]
  587. # Mask
  588. img_mask = create_foreground_mask(img, threshold_foreground=MASK_THRESHOLD_FOREGROUND, threshold_area_min_object=MASK_AREA_MIN_OBJECT, threshold_area_max_object=MASK_AREA_MAX_OBJECT)
  589. worm_mask = extract_worm_mask(img_mask, coords_center=WORM_CENTER_ESTIMATE, size_close=WORM_SIZE_CLOSE)
  590. # NaNed
  591. img_naned = img.astype(np.float32)
  592. img_naned[~worm_mask] = np.nan
  593. # Intensities
  594. infos['intensities_skeleton'][idx] = img_naned[skeleton_int[:,1], skeleton_int[:,0]]
  595. infos['intensities_skeleton_normals'][idx] = np.nanmean(
  596. img_naned[skeleton_interp_um_normals[:,1], skeleton_interp_um_normals[:,0]],
  597. axis=-1
  598. )
  599. infos['widths_skeleton_normals'][idx] = np.sum(
  600. ~np.isnan(img_naned[skeleton_interp_um_normals[:,1], skeleton_interp_um_normals[:,0]]),
  601. axis=-1
  602. )
  603. infos['intensities_skeleton_normals_full'][idx] = img_naned[skeleton_interp_um_normals[:,1], skeleton_interp_um_normals[:,0]]
  604. # Store
  605. ## Numpy
  606. np.savez_compressed(
  607. FP_WRITE_NPZ_KYMOGRAPH_ALL,
  608. timestamps = times_beh[INDICES_TO_CONSIDER],
  609. kymograph_skeleton = infos['intensities_skeleton'],
  610. kymograph_skeleton_normals = infos['intensities_skeleton_normals'],
  611. intensities_skeleton_normals_full = infos['intensities_skeleton_normals_full'],
  612. distance_from_nose = SKELETON_INTENSITY_STEPS_UM,
  613. normal_scales_pixel = np.arange(-SKELETON_NORMALS_HALF_LENGTH_PIXELS, SKELETON_NORMALS_HALF_LENGTH_PIXELS+1).astype(np.float32),
  614. )
  615. ## Matlab
  616. savemat(
  617. FP_WRITE_MAT_KYMOGRAPH_ALL,
  618. dict(
  619. timestamps = times_beh[INDICES_TO_CONSIDER],
  620. kymograph_skeleton = infos['intensities_skeleton'],
  621. kymograph_skeleton_normals = infos['intensities_skeleton_normals'],
  622. distance_from_nose = SKELETON_INTENSITY_STEPS_UM,
  623. normal_scales_pixel = np.arange(-SKELETON_NORMALS_HALF_LENGTH_PIXELS, SKELETON_NORMALS_HALF_LENGTH_PIXELS+1).astype(np.float32),
  624. )
  625. )
  626. #
  627. _ = gc.collect()
  628. def plotting_function(kymograph, fp_write, title = None):
  629. plt.ioff()
  630. plt.figure(figsize=FIGURE_SIZE_LARGE, dpi=FIGURE_DPI)
  631. plt.title(title)
  632. plt.imshow( kymograph, cmap='gray')
  633. # X ticks
  634. _ticks = np.arange(NT)
  635. _labels = (1000*(times_beh[INDICES_TO_CONSIDER] - times_beh[INDICES_TO_CONSIDER[0]]).round(5) ).astype(np.int64)
  636. plt.xticks(ticks=_ticks[::TICK_INTERVAL_TIME], labels=_labels[::TICK_INTERVAL_TIME], rotation=90)
  637. plt.xlabel("Milliseconds")
  638. # Y ticks
  639. _n = kymograph.shape[0]
  640. _ticks = np.arange(len(dists_to_interpolate_px))[:_n]
  641. _labels = ( dists_to_interpolate_px * UM_PER_PIXEL ).round(1)[-_n:]
  642. plt.yticks(ticks=_ticks[::TICK_INTERVAL_DISTANCE], labels=_labels[::TICK_INTERVAL_DISTANCE])
  643. plt.ylabel("Distance from nose (um)")
  644. plt.savefig(fp_write, bbox_inches='tight')
  645. plt.clf()
  646. plt.cla()
  647. plt.close('all')
  648. _ = gc.collect()
  649. return
  650. ############################################
  651. plotting_function(
  652. kymograph = infos['intensities_skeleton'].T[:,:],
  653. fp_write = FP_WRITE_IMAGE_KYMOGRAPH,
  654. title = "Kymograph of intensity along the body"
  655. )
  656. plotting_function(
  657. kymograph = infos['intensities_skeleton_normals'].T[:,:],
  658. fp_write = FP_WRITE_IMAGE_KYMOGRAPH_NORMALS,
  659. title = "Kymograph of intensity along normals along the body"
  660. )
  661. ############################################
  662. # Normalize the kymograph?!
  663. _tmp = infos['intensities_skeleton'].T.copy()
  664. _tmp = _tmp[:, :]
  665. _tmp = np.clip(
  666. 128*(_tmp / np.nanmean(_tmp, axis=0, keepdims=True))**1.5,
  667. 0, 255
  668. )
  670. plt.ioff()
  671. plt.figure(figsize=FIGURE_SIZE_XLARGE, dpi=FIGURE_DPI)
  672. plt.title("Kymograph of intensity along the body - Rescaled")
  673. plt.imshow( _tmp, cmap='gray')
  674. # X ticks
  675. _ticks = np.arange(NT)
  676. _labels = (1000*(times_beh[INDICES_TO_CONSIDER] - times_beh[INDICES_TO_CONSIDER[0]]).round(5) ).astype(np.int64)
  677. plt.xticks(ticks=_ticks[::TICK_INTERVAL_TIME], labels=INDICES_TO_CONSIDER[::TICK_INTERVAL_TIME], rotation=90)
  678. plt.xlabel("Milliseconds")
  679. # Y ticks
  680. _ticks = np.arange(len(dists_to_interpolate_px))[:100]
  681. _labels = ( dists_to_interpolate_px * UM_PER_PIXEL ).round(1)[:100]
  682. plt.yticks(ticks=_ticks[::TICK_INTERVAL_DISTANCE], labels=_labels[::TICK_INTERVAL_DISTANCE])
  683. plt.ylabel("Distance from nose (um)")
  684. plt.savefig(FP_WRITE_IMAGE_KYMOGRAPH_SCALED, bbox_inches='tight')
  685. plt.clf()
  686. plt.cla()
  687. plt.close('all')
  688. ############################################
  689. # Normalize the kymograph?!
  690. _tmp = infos['intensities_skeleton_normals'].T.copy()
  691. _tmp = _tmp[:, :]
  692. _tmp = np.clip(
  693. 128*(_tmp / np.nanmean(_tmp, axis=0, keepdims=True))**1.5,
  694. 0, 255
  695. )
  697. plt.ioff()
  698. plt.figure(figsize=FIGURE_SIZE_XLARGE, dpi=FIGURE_DPI)
  699. plt.title("Kymograph of intensity along the body - Rescaled")
  700. plt.imshow( _tmp, cmap='gray')
  701. # X ticks
  702. _ticks = np.arange(NT)
  703. _labels = (1000*(times_beh[INDICES_TO_CONSIDER] - times_beh[INDICES_TO_CONSIDER[0]]).round(5) ).astype(np.int64)
  704. plt.xticks(ticks=_ticks[::TICK_INTERVAL_TIME], labels=INDICES_TO_CONSIDER[::TICK_INTERVAL_TIME], rotation=90)
  705. plt.xlabel("Milliseconds")
  706. # Y ticks
  707. _ticks = np.arange(len(dists_to_interpolate_px))[:100]
  708. _labels = ( dists_to_interpolate_px * UM_PER_PIXEL ).round(1)[:100]
  709. plt.yticks(ticks=_ticks[::TICK_INTERVAL_DISTANCE], labels=_labels[::TICK_INTERVAL_DISTANCE])
  710. plt.ylabel("Distance from nose (um)")
  711. plt.savefig(FP_WRITE_IMAGE_KYMOGRAPH_NORMALS_SCALED, bbox_inches='tight')
  712. plt.clf()
  713. plt.cla()
  714. plt.close('all')
  715. _ = gc.collect()
  718. #######################################################################
  719. # Main Function
  720. #
  721. # This function is the entry point for the script. It loads the files,
  722. # processes the kymographs, and saves the results.
  723. #######################################################################
  724. def download_sample_data(data_dir):
  725. """
  726. Download and extract the sample data from the GitHub release.
  728. The ZIP file is downloaded from the Yeon-2025-pumping-analysis GitHub
  729. release page and extracted into the data directory.
  731. Compatible with Windows, macOS, and Linux. Uses only Python standard
  732. library modules (plus tqdm for progress display).
  734. Args:
  735. data_dir: Path to the data directory where files will be extracted
  736. """
  737. import urllib.request
  738. import zipfile
  739. import tempfile
  741. DATA_URL = "https://github.com/venkatachalamlab/Yeon-2025-pumping-analysis/releases/download/v1.0/data.zip"
  742. CHUNK_SIZE = 8192 # 8 KB chunks for streaming download
  744. print(f"Sample data not found at: {data_dir}")
  745. print(f"Downloading sample data from GitHub release...")
  746. print(f" URL: {DATA_URL}")
  748. # Use a temporary file for the download (cross-platform safe)
  749. tmp_fd, zip_path = tempfile.mkstemp(suffix=".zip")
  750. os.close(tmp_fd) # Close the file descriptor; we'll open it ourselves
  752. try:
  753. # Download with progress bar
  754. response = urllib.request.urlopen(DATA_URL)
  755. total_size = int(response.headers.get("Content-Length", 0))
  757. with open(zip_path, "wb") as f:
  758. with tqdm(total=total_size, unit="B", unit_scale=True,
  759. unit_divisor=1024, desc="Downloading") as pbar:
  760. while True:
  761. chunk = response.read(CHUNK_SIZE)
  762. if not chunk:
  763. break
  764. f.write(chunk)
  765. pbar.update(len(chunk))
  767. print(f" Download complete.")
  768. except Exception as e:
  769. print(f"ERROR: Failed to download sample data: {e}")
  770. print(f"Please download manually from:")
  771. print(f" {DATA_URL}")
  772. print(f"Then extract into: {data_dir}")
  773. if os.path.exists(zip_path):
  774. os.remove(zip_path)
  775. exit(1)
  777. # Extract with progress bar
  778. print(f"Extracting to: {data_dir}")
  779. os.makedirs(data_dir, exist_ok=True)
  780. try:
  781. with zipfile.ZipFile(zip_path, "r") as zip_ref:
  782. members = zip_ref.infolist()
  783. with tqdm(total=len(members), unit="file", desc="Extracting") as pbar:
  784. for member in members:
  785. zip_ref.extract(member, data_dir)
  786. pbar.update(1)
  787. print(f" Extraction complete.")
  788. except Exception as e:
  789. print(f"ERROR: Failed to extract sample data: {e}")
  790. exit(1)
  791. finally:
  792. # Clean up the temporary ZIP file
  793. if os.path.exists(zip_path):
  794. os.remove(zip_path)
  796. print(f"Sample data is ready at: {data_dir}")
  799. if __name__ == "__main__":
  800. # Check if any behavior recording folders exist in the data directory.
  801. # Note: config.py creates data/ and its subdirectories on import, so
  802. # we check for actual *_behavior folders with .h5 files instead.
  803. _behavior_folders = glob(os.path.join(FP_READ_FOLDER, "*_behavior"))
  804. if len(_behavior_folders) == 0:
  805. download_sample_data(FP_READ_FOLDER)
  807. print(f"Starting kymograph generation for data in: {FP_READ_FOLDER}")
  809. # Expected folder and files structure
  810. # FP_READ_FOLDER
  811. # |-> WORM1_behavior
  812. # | |-> 000.h5
  813. # | |-> 001.h5
  814. # |-> WORM2_behavior
  815. # | |-> 000.h5
  816. # ...
  817. # Run
  818. files_beh, _, times_beh, series_beh = load_files_data_times_persistent(
  819. fp_folder=os.path.join( FP_READ_FOLDER, "*_behavior" ),
  820. fp_folder_persistence=os.path.join( FP_READ_FOLDER, "metadata" )
  821. )
  822. _, NX, NY = series_beh.shape
  823. # Annotation texts
  824. _n = len(times_beh)
  825. texts = [ "" ]
  826. for idx in range(1,_n):
  827. _T = times_beh[idx]-times_beh[0]
  828. _fps = 1/(times_beh[idx]-times_beh[idx-1])
  829. texts.append(
  830. ", {:>6.2f}s [fps: {:>4.1f}]".format(_T, _fps)
  831. )
  832. print(f"Behavior Series Loaded: records={len(series_beh)}")
  835. # Figure out files frame counts
  836. ns_per_recording = dict()
  837. recording_states = list()
  838. for file, n in zip(files_beh, series_beh.ns):
  839. name_recording = file.filename.split(os.sep)[-2]
  840. worm_id, condition, strain = name_recording.split("_")[:3]
  841. if name_recording not in ns_per_recording:
  842. ns_per_recording[name_recording] = n
  843. recording_states.append((worm_id, condition, strain))
  844. else:
  845. ns_per_recording[name_recording] += n
  846. indices_per_recording = np.array([0] + [
  847. ns_per_recording[k] for k in sorted(ns_per_recording)
  848. ])
  849. indices_per_recording = np.cumsum(indices_per_recording)
  850. print(list(zip( indices_per_recording[:-1], indices_per_recording[1:] )))
  852. # Manual Head-Tail confusion fixes
  853. # Possible good candidate that might have pumping as well
  854. from collections import defaultdict
  856. ## Intervals to extrct pumping from
  857. # e.g. this is by default the whole recording
  858. indices_inbetween_pairs = list(zip( indices_per_recording[:-1], indices_per_recording[1:] ))
  859. print(indices_inbetween_pairs)
  861. ## Indices where skeleton head-tail is confused
  862. ## Make sure you only add indices once, and only do it once for each interval
  863. # e.g. the head-tail remains consistent until the worm bends or the skeleton is not extractable by tierpsy
  864. # after the skeleton is again calculable, it might get head and tail confused.
  865. indices_skeleton_reverse = defaultdict(set)
  866. indices_skeleton_reverse[(0, 400)] = {0,}
  867. indices_skeleton_reverse[(400, 800)] = {400,}
  868. # indices_skeleton_reverse[(0, len(times_beh))] = set() # Add frame indices from the annotated video where the confusion starts and it will be flipped for the following frames as well
  869. # E.g. indices_skeleton_reverse[(0, 5956)] = { 1772, 2567, 4428, }
  870. # This means that the skeleton is reversed at frames 1772, 2567, 4428.
  871. # MANUAL PART! -> you need to add the indices manually if needed.
  873. # Make videos, kymographs and store data for all
  874. for (idx_start, idx_end), (worm_id, condition, strain) in zip(indices_inbetween_pairs,recording_states):
  875. print(f"##### {datetime.datetime.now()} Interval processing: {str(idx_start).zfill(8)}_{str(idx_end).zfill(8)}")
  876. # Extract all
  877. key = (idx_start, idx_end)
  878. ## Create Paths
  879. fp_read_pumping_kymograph = os.path.join(
  880. FP_PUMPING_EXTRACTS,
  881. f"{worm_id}_{condition}_{strain}_pumping_{str(idx_start).zfill(8)}_{str(idx_end).zfill(8)}_kymograph_all.npz"
  882. )
  883. fp_write_pumping_kymograph_png = os.path.join(
  884. FP_PUMPING_EXTRACTS,
  885. f"{worm_id}_{condition}_{strain}_pumping_{str(idx_start).zfill(8)}_{str(idx_end).zfill(8)}_kymograph_normals_true.png"
  886. )
  887. # Skip if exists
  888. if os.path.exists(fp_write_pumping_kymograph_png):
  889. continue
  890. # Report
  891. print("####"*20)
  892. print(f"#### {datetime.datetime.now()} Procesing interval: {str(idx_start).zfill(8)}-{str(idx_end).zfill(8)}")
  893. print("####"*20)
  894. # Do the thing
  895. process_kymograph_segment(idx_start, idx_end, indices_skeleton_reverse=indices_skeleton_reverse[key], worm_id=worm_id, condition=condition, strain=strain )
  896. print("####"*20)
  897. print(f"#### {datetime.datetime.now()} Finished!")
  898. print("####"*20)
  899. # Load Kymograph convert and write
  900. with np.load(fp_read_pumping_kymograph) as file_kymograph:
  901. # Load & Convert
  902. food_entry_normals_kymograph_uint8 = file_kymograph['kymograph_skeleton_normals']
  903. food_entry_normals_kymograph_uint8[np.isnan(food_entry_normals_kymograph_uint8)] = 255.0
  904. food_entry_normals_kymograph_uint8 = np.clip(food_entry_normals_kymograph_uint8, 0.0, 255.0).astype(np.uint8)
  905. ## Resize
  906. nx, ny = food_entry_normals_kymograph_uint8.shape
  907. food_entry_normals_kymograph_uint8 = cv.resize( food_entry_normals_kymograph_uint8, (ny, nx*IMAGE_RESIZE_FACTOR) )
  908. # Write
  909. plt.imsave(
  910. fp_write_pumping_kymograph_png,
  911. food_entry_normals_kymograph_uint8.T, cmap='gray',
  912. vmin=np.floor(np.nanmin(food_entry_normals_kymograph_uint8)), vmax=np.ceil(np.nanmax(food_entry_normals_kymograph_uint8))
  913. )
  915. # Load all NPZ files and create rolled kymographs
  916. fps_cases = sorted(glob(
  917. os.path.join(FP_PUMPING_EXTRACTS, "*.npz")
  918. ))
  919. print(f"Found {len(fps_cases)} cases")
  920. if len(fps_cases) == 0:
  921. raise ValueError(f"No NPZ files found in {FP_PUMPING_EXTRACTS}")
  923. # Generate aligned kymograph images for manual annotation
  924. for fp_npz in tqdm(fps_cases):
  925. # File path
  926. filename = fp_npz.split(os.sep)[-1]
  927. fp_write_png = os.path.join(
  928. FP_PUMPING_ANALYSIS,
  929. f"{filename[:-4]}.png"
  930. )
  931. # Skip if exists
  932. if os.path.exists(fp_write_png):
  933. continue
  934. # Load
  935. intensities_skeleton_normals_avg, intensities_skeleton_normals_avg_rolled = load_and_align_kymograph(fp_npz)
  936. # Store
  937. plt.imsave(
  938. fp_write_png,
  939. intensities_skeleton_normals_avg_rolled.T,
  940. cmap='gray',
  941. vmin=np.nanquantile( intensities_skeleton_normals_avg_rolled, 0.01 ),
  942. vmax=np.nanquantile( intensities_skeleton_normals_avg_rolled, 0.99 )
  943. )

01_make_kymographs.py at commit 2157177, under MIT · at the source

Overview

Authors: Jihye Yeon1, Jinmahn Kim2, Koji Sato3, Stephen Nurrish1, Laurie Chen1, Nikhila Krishnan1, Sam Bates1, Sayoko Ihara3, Sina Rasouli2, Charmi Porwal1,4, Vivek Venkatachalam2, Kazushige Touhara3, Piali Sengupta1
ORCID iDs: Jihye Yeon, Stephen Nurrish, Sina Rasouli, Kazushige Touhara, Piali Sengupta
  1. Department of Biology, Brandeis University, Waltham, MA USA
  2. Department of Physics, Northeastern University, Boston, MA USA
  3. Department of Applied Biological Chemistry, Graduate School of Agricultural and Life Sciences, The University of Tokyo, Tokyo, Japan
  4. Present Address: Department of Biology, State University of New York, Albany, NY USA
Institutions: Brandeis University (United States); Northeastern University (United States); The University of Tokyo (Japan); State University of New York (United States); University at Albany, State University of New York (United States)
Journal: Nature, volume 654, issue 8120, pages 1023-1032
Dates: received 22 March 2025; accepted 2 March 2026; published online 1 April 2026; in print 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41586-026-10348-3 · PMID 41922765 · PMCID PMC13293861 · OpenAlex W7147035867
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: C. elegans (organism), cellular / molecular (subfield)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Evoked potentials, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: Sensory processing, Ion channels in the nervous system, Stress and resilience
MeSH: Caenorhabditis elegans*, Caenorhabditis elegans Proteins*, Enteric Nervous System*, Neurons*, Salt Tolerance*, Acclimatization, Animals, Mutation, Pharynx, Salt Stress, Signal Transduction (* major topic)
Topic: Genetics, Aging, and Longevity in Model Organisms (Aging, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NINDS NIH HHS (R01 NS126334); NIGMS NIH HHS (R35 GM122463); NIDDK NIH HHS (R01 DK142077)
Citations: cited by 1 paper (Europe PMC); 76 references in the paper
Research resources: RRID:SCR_025892

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.

venkatachalamlab/Yeon-2025-pumping-analysis

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 21571776c1725b6b5da0816ac40a3da81de16fd0, 10 February 2026
Languages: Python (198), Shell (6), C (2)
Size: 301 files, 206 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, tierpsy-tracker/requirements.txt, tierpsy-tracker/setup.py, tierpsy-tracker/docker/Dockerfile, tierpsy-tracker/tierpsy/analysis/ske_create/segWormPython/cython_files/_old/setup.py), tests, documentation
Not found: CITATION.cff, continuous integration
Tools: NumPy (98 files), pandas (46 files), OpenCV (26 files), SciPy (24 files), Matplotlib (19 files), PyTorch (8 files), scikit-image (5 files), h5py (3 files), Keras (3 files), scikit-learn (2 files), Numba (1 file), Pillow (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
208 files
At the source: github.com/venkatachalamlab/Yeon-2025-pumping-analysis

Zenodo 13748735

License: CC-BY-4.0
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
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:

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:

Read it in the paper: doi.org/10.1038/s41586-026-10348-3.

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;
  • 206 scripts, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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 statement

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

Read it in the paper: doi.org/10.1038/s41586-026-10348-3.

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 2, 28 September 2026

  • Publisher: n/a → Nature Portfolio

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 13 authors, 3 keywords, 11 MeSH terms, 3 funders, 75 references, 1 RRID.

Cite

This paper

Yeon, J., Kim, J., Sato, K., Nurrish, S., Chen, L., Krishnan, N., Bates, S., Ihara, S., Rasouli, S., Porwal, C., Venkatachalam, V., Touhara, K., & Sengupta, P. (2026). An enteric neuron ionotropic receptor regulates salt stress resistance. Nature, 654(8120), 1023-1032. https://doi.org/10.1038/s41586-026-10348-3

BibTeX

@article{yeon2026enteric,
author = {Yeon, Jihye and Kim, Jinmahn and Sato, Koji and Nurrish, Stephen and Chen, Laurie and Krishnan, Nikhila and Bates, Sam and Ihara, Sayoko and Rasouli, Sina and Porwal, Charmi and Venkatachalam, Vivek and Touhara, Kazushige and Sengupta, Piali},
title = {{An enteric neuron ionotropic receptor regulates salt stress resistance}},
journal = {Nature},
year = {2026},
month = apr,
volume = {654},
number = {8120},
pages = {1023--1032},
publisher = {Nature Portfolio},
issn = {0028-0836},
doi = {10.1038/s41586-026-10348-3},
url = {https://doi.org/10.1038/s41586-026-10348-3},
pmid = {41922765},
pmcid = {PMC13293861}
}

RIS

TY - JOUR
AU - Yeon, Jihye
AU - Kim, Jinmahn
AU - Sato, Koji
AU - Nurrish, Stephen
AU - Chen, Laurie
AU - Krishnan, Nikhila
AU - Bates, Sam
AU - Ihara, Sayoko
AU - Rasouli, Sina
AU - Porwal, Charmi
AU - Venkatachalam, Vivek
AU - Touhara, Kazushige
AU - Sengupta, Piali
TI - An enteric neuron ionotropic receptor regulates salt stress resistance
T2 - Nature
J2 - Nature
PY - 2026
DA - 2026/04/01
VL - 654
IS - 8120
SP - 1023
EP - 1032
SN - 0028-0836
PB - Nature Portfolio
DO - 10.1038/s41586-026-10348-3
UR - https://doi.org/10.1038/s41586-026-10348-3
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41586-026-10348-3",
"type": "article-journal",
"title": "An enteric neuron ionotropic receptor regulates salt stress resistance",
"container-title": "Nature",
"author": [
{
"family": "Yeon",
"given": "Jihye"
},
{
"family": "Kim",
"given": "Jinmahn"
},
{
"family": "Sato",
"given": "Koji"
},
{
"family": "Nurrish",
"given": "Stephen"
},
{
"family": "Chen",
"given": "Laurie"
},
{
"family": "Krishnan",
"given": "Nikhila"
},
{
"family": "Bates",
"given": "Sam"
},
{
"family": "Ihara",
"given": "Sayoko"
},
{
"family": "Rasouli",
"given": "Sina"
},
{
"family": "Porwal",
"given": "Charmi"
},
{
"family": "Venkatachalam",
"given": "Vivek"
},
{
"family": "Touhara",
"given": "Kazushige"
},
{
"family": "Sengupta",
"given": "Piali"
}
],
"container-title-short": "Nature",
"volume": "654",
"issue": "8120",
"page": "1023-1032",
"DOI": "10.1038/s41586-026-10348-3",
"PMID": "41922765",
"PMCID": "PMC13293861",
"ISSN": "0028-0836",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41586-026-10348-3",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41593-026-02257-5 [code]
Neural sequences underlying directed turning in Caenorhabditis elegans.
Journal: Nature neuroscience
In common: h5py, Pillow, PyTorch, 4 other tools, C. elegans, 7 references
[2] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: Keras, Numba, OpenCV, 10 other tools
[3] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Keras, Numba, OpenCV, 9 other tools, cellular / molecular
[4] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: Keras, Numba, OpenCV, 9 other tools
[5] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: Numba, OpenCV, scikit-image, 9 other tools, 1 reference
[6] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: Keras, Numba, OpenCV, 8 other tools, cellular / molecular, 1 reference
[7] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: Keras, Numba, OpenCV, 9 other tools
[8] doi:10.1016/j.cub.2026.06.016 [code]
Neuronal RNAi and oxygen-sensing circuit shape germline resilience to heat stress.
Journal: Current biology : CB
In common: Numba, statsmodels, scikit-learn, 4 other tools, C. elegans, 4 references
[9] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: Numba, OpenCV, scikit-image, 9 other tools
[10] doi:10.1038/s41467-026-72709-w [code]
An epifluorescence microscope design for naturalistic behavior and cellular activity in freely moving Caenorhabditis elegans.
Journal: Nature communications
In common: OpenCV, scikit-image, h5py, 6 other tools, C. elegans, cellular / molecular, 1 reference

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.