OSCR

Retinoic acid drives cell fate specification, maturation and retinal regionality in human retinal organoids.

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 · 2,149 lines · 82 KB · CC0-1.0

  1. """
  2. Written by: Pete, 2023, (peterlionelnewman @ github)
  3. Helpful for students
  4. 1. GUI interface to:
  5. 2. search a folder for .czi files
  6. 3. export mips of various kinds for each czi channel
  7. 4. morphometrics about the images
  8. Go check out the Allen Institue of Cell Science package !!!
  9. This exists to help students with mip generation, and because of the bugs in the mosaic builder
  10. """
  12. # std
  13. import csv
  14. from functools import partial
  15. import itertools
  16. import os
  17. from multiprocessing import Pool, cpu_count
  18. import pickle
  19. import platform
  20. import re
  21. import time
  22. from tkinter.filedialog import askdirectory
  23. import tkinter as tk
  24. from tkinter import ttk
  25. import warnings
  26. import xml.etree.ElementTree as ET
  28. # 3rd
  29. import aicspylibczi
  30. import attr
  31. from cellpose import models
  32. import cv2
  33. from itertools import product
  34. from matplotlib import pyplot as plt
  35. import numpy as np
  36. from PIL import Image, ImageOps, ImageDraw, ImageFont, ImageChops, ImageTk
  37. import pyvista as pv
  38. from readlif.reader import LifFile
  39. from scipy.ndimage import zoom, binary_fill_holes, distance_transform_edt, binary_dilation, binary_erosion
  40. from skimage.measure import regionprops, label
  41. from skimage import morphology
  42. from torch import device
  43. import torch
  44. from tqdm import tqdm
  45. import webcolors
  48. global SO, DEVICE
  50. if torch.cuda.is_available():
  51. print("CUDA is available. PyTorch can use GPUs!")
  52. DEVICE = torch.device('cuda')
  53. elif torch.backends.mps.is_available():
  54. print("PyTorch using GPU on mac.")
  55. DEVICE = torch.device('mps')
  56. else:
  57. print("CPU ONLY. PyTorch can only use CPUs.")
  58. DEVICE = torch.device('cpu')
  60. @attr.s(auto_attribs=True, auto_detect=True)
  61. class ProcessOptions:
  62. # image path
  63. image_path: str = attr.ib(default='')
  64. save_path: str = attr.ib(default='')
  66. # save options
  67. save_mip_channels: bool = attr.ib(default=False)
  68. save_mip_panel: bool = attr.ib(default=True)
  69. save_mip_merge: bool = attr.ib(default=False)
  70. save_dye_overlaid: bool = attr.ib(default=True)
  71. save_colors: bool = attr.ib(default=True)
  72. use_multiprocessing: bool = attr.ib(default=False)
  74. # segmentation options
  75. segment_image: bool = attr.ib(default=False)
  76. mask_ch: int = attr.ib(default=0)
  77. cyto: bool = attr.ib(default=False)
  78. nuc: bool = attr.ib(default=False)
  79. channels_of_interest: list = attr.ib(default=[0])
  80. # same_for_all_images: bool = attr.ib(default=False)
  82. def __setattr__(self, name, value):
  83. super().__setattr__(name, value)
  84. if name == 'image_path':
  85. self.save_path = os.path.join(os.path.dirname(value), 'save')
  88. @attr.s(auto_attribs=True, auto_detect=True)
  89. class SegmentationOptions:
  91. mask_channel_var: int = attr.ib(default=0)
  92. cyto_var: bool = attr.ib(default=False)
  93. nuc_var: bool = attr.ib(default=True)
  94. segment_2D: bool = attr.ib(default=True)
  95. segment_3D: bool = attr.ib(default=False)
  96. same_for_all_images_var: bool = attr.ib(default=True)
  97. channel_vars: list = attr.ib(default=[0])
  98. mask_channel: int = attr.ib(default=0)
  99. channels_of_interest_vars: list = attr.ib(default=[])
  102. @attr.s(auto_attribs=True, auto_detect=True)
  103. class MaskProperties2D:
  105. centroid: np.array = attr.ib(default=np.array([[],[]]).T)
  106. id: np.array = attr.ib(default=np.array([]))
  107. area: np.array = attr.ib(default=np.array([]))
  108. perimeter: np.array = attr.ib(default=np.array([]))
  109. form_factor: np.array = attr.ib(default=np.array([]))
  110. minor_ax: np.array = attr.ib(default=np.array([]))
  111. major_ax: np.array = attr.ib(default=np.array([]))
  112. eccentricity: np.array = attr.ib(default=np.array([]))
  113. convexity: np.array = attr.ib(default=np.array([]))
  114. orientation: np.array = attr.ib(default=np.array([]))
  115. mask_sat: np.array = attr.ib(default=np.array([]))
  116. tf_sat: np.array = attr.ib(default=np.array([]))
  117. dist_from_edge: np.array = attr.ib(default=np.array([]))
  120. @attr.s(auto_attribs=True, auto_detect=True)
  121. class MaskProperties3D:
  123. id: np.array = attr.ib(default=np.array([]))
  124. volume: np.array = attr.ib(default=np.array([]))
  125. centroid: np.array = attr.ib(default=np.array([[], [], []]).T)
  126. surface_area: np.array = attr.ib(default=np.array([]))
  127. sphericity: np.array = attr.ib(default=np.array([]))
  128. major_ax: np.array = attr.ib(default=np.array([]))
  129. minor_ax: np.array = attr.ib(default=np.array([]))
  130. least_ax: np.array = attr.ib(default=np.array([]))
  131. eccentricity: np.array = attr.ib(default=np.array([]))
  132. convexity: np.array = attr.ib(default=np.array([]))
  133. orientation: np.array = attr.ib(default=np.array([]))
  134. mask_sat: np.array = attr.ib(default=np.array([]))
  135. tf_sat: np.array = attr.ib(default=np.array([[], []]).T)
  138. @attr.s(auto_attribs=True, auto_detect=True)
  139. class BioImage:
  140. """
  141. czi image class for lite image processing
  142. wrapper class around the ACIS wrapper class;
  143. around the czilib library
  144. """
  146. path: str = attr.ib(default='')
  147. imfile: aicspylibczi.CziFile = attr.ib(default=None)
  148. czi: tuple = attr.ib(default=())
  149. im: np.ndarray = attr.ib(default=[0., 0.])
  150. cell_mass: np.ndarray = attr.ib(default=[0., 0.])
  151. mosaic: np.ndarray = attr.ib(default=[0., 0.])
  152. num_channels: int = attr.ib(default=0)
  153. num_z_slices: int = attr.ib(default=0)
  154. height: int = attr.ib(default=0)
  155. width: int = attr.ib(default=0)
  156. num_timepoints: int = attr.ib(default=0)
  157. num_scenes: int = attr.ib(default=0)
  158. num_blocks: int = attr.ib(default=0)
  159. num_mosaics: int = attr.ib(default=0)
  160. metadata: str = attr.ib(default='')
  161. nmip: np.ndarray = attr.ib(default=[0., 0.])
  162. mip: np.ndarray = attr.ib(default=[0., 0.])
  163. colours: list = attr.ib(default=[])
  164. dyes: list = attr.ib(default=[])
  165. scale: np.array = attr.ib(default=[1., 1., 1.])
  166. bbox: np.array = attr.ib(default=np.array([0., 0.]))
  168. mask: np.ndarray = attr.ib(default=np.array([]))
  169. mask_ch: int = attr.ib(default=0)
  170. mask_props: MaskProperties2D = attr.ib(default=MaskProperties2D())
  172. big_image: bool = attr.ib(default=False)
  174. def load_tif(self):
  176. """
  177. load a tif file
  178. """
  180. # get the number of channels, z_slices and shape
  181. os.chdir(os.path.dirname(self.path))
  183. all_images = []
  184. self.num_channels = 0
  186. # search for tif files with same name
  187. for root, _, files in os.walk(os.path.dirname(self.path)):
  188. for file in files:
  189. if file.endswith('.tif'):
  190. if file[0] == '.':
  191. continue
  192. if os.path.basename(self.path)[:-4] in file\
  193. and not file == os.path.basename(self.path):
  194. all_images.append(file)
  195. self.num_channels += 1
  197. self.num_z_slices = 1
  199. if not all_images:
  200. print('No tif files found')
  201. return
  203. (self.width, self.height, _) = plt.imread(all_images[0]).shape
  204. self.metadata = ''
  205. self.scale = -1
  207. self.im = np.zeros((self.num_channels, self.num_z_slices, self.height, self.width))
  209. self.colours = []
  210. self.dyes = []
  212. # convert im to f64
  213. for c in range(self.num_channels):
  214. im = plt.imread(all_images[c]).astype(np.float64)
  216. # Get the R, G, and B channels
  217. r, g, b = im[:, :, 0], im[:, :, 1], im[:, :, 2]
  218. # r, g, b = im[:, :, 1], im[:, :, 2], im[:, :, 0]
  220. # Calculate the grayscale image
  221. self.im[c, 0, :, :] = 0.2989 * r + 0.5870 * g + 0.1140 * b
  223. color = [r.max(), g.max(), b.max()]
  224. color /= np.max(color)
  225. color = (color * 255).astype(int)
  226. self.colours.append(color)
  227. self.dyes.append(webcolors.rgb_to_name(color))
  229. self.scale = np.array([1., 1., 1.])
  231. def load_czi(self):
  232. """
  233. load a czi file
  234. """
  236. # get the image
  237. if self.path.endswith('.czi'):
  238. self.imfile = aicspylibczi.CziFile(self.path)
  239. else:
  240. # Set color to red
  241. print('\033[91m', end='')
  242. print(f'Failed to process: {self.path}')
  243. # Reset color to default
  244. print('\033[0m', end='')
  246. dims = self.imfile.get_dims_shape()[0]
  248. if dims['X'][1] == 0 and dims['Y'][1] == 0:
  249. return 'metadata_only'
  251. # get the number of channels, z_slices and shape
  252. self.num_channels = dims['C'][1]
  253. self.num_z_slices = dims['Z'][1]
  254. self.width = dims['X'][1]
  255. self.height = dims['Y'][1]
  257. self.metadata = self.imfile.meta
  258. # looks like the first 3 distance/values are camera props?
  259. self.scale = np.array([float(self.metadata.findall('.//Distance/Value')[i].text) for i in range(3, 6)])[::-1]
  260. self.scale = self.scale * 1e6
  262. # load each image
  263. if self.imfile.is_mosaic():
  265. # additional checks
  266. if not 'M' in dims:
  267. raise ValueError('Mosaic image found, but no M dimension found')
  269. # load in all the bounding boxes
  270. self.num_mosaics = dims['M'][1]
  271. self.bbox = np.zeros((self.num_mosaics, 4)).astype(int)
  272. for m in range(self.num_mosaics):
  273. _ = self.imfile.get_mosaic_tile_bounding_box(C=0, Z=0, M=m)
  274. self.bbox[m, :] = int(_.x), int(_.y), int(_.w), int(_.h)
  276. # check that w and h is the same
  277. if not np.all(self.bbox[:, 2] == self.bbox[0, 2]) or not np.all(self.bbox[:, 3] == self.bbox[0, 3]):
  278. raise ValueError('Mosaic bounding boxes are not the same size')
  280. # simplify the box
  281. self.bbox[:, 0] = self.bbox[:, 0] - np.min(self.bbox[:, 0])
  282. self.bbox[:, 1] = self.bbox[:, 1] - np.min(self.bbox[:, 1])
  284. # initialize the image
  285. self.width = np.max(self.bbox[:, 0]) + self.bbox[0, 2]
  286. self.height = np.max(self.bbox[:, 1]) + self.bbox[0, 3]
  288. # get the 'im' == (czyx)
  289. self.mosaic = np.moveaxis(self.imfile.read_image()[0],
  290. [self.imfile.dims.index('C'),
  291. self.imfile.dims.index('Z'),
  292. self.imfile.dims.index('Y'),
  293. self.imfile.dims.index('X'),
  294. self.imfile.dims.index('M')],
  295. [0, 1, 2, 3, 4])
  297. # index the last dimensions at 0
  298. for i in range(len(dims) - 5):
  299. self.mosaic = self.mosaic[..., 0]
  301. # look at the size of im and cry if really large
  302. if (self.mosaic.nbytes / 1e9) > 5:
  303. self.big_image = True
  304. print(f'WARNING: Image size is {self.mosaic.nbytes / 1e9} GB, this may cause memory issues')
  305. return
  307. # move the mosaics into im - some rounding bug? means I need to add 1 to the width and height
  308. self.im = np.zeros((self.num_channels, self.num_z_slices, self.height + 1, self.width + 1))
  310. print(f'loading mosaic')
  311. for m in range(self.num_mosaics):
  312. if m % (self.num_mosaics // 10) == 0:
  313. print(f'.', end='')
  314. self.im[:, :, self.bbox[m, 1]:self.bbox[m, 1] + self.bbox[m, 3], self.bbox[m, 0]:self.bbox[m, 0] + self.bbox[m, 2]] = self.mosaic[:, :, :, :, m]
  316. else:
  317. self.im = self.imfile.read_image()
  319. # get the 'im' == (czyx)
  320. self.im = np.moveaxis(self.im[0],
  321. [self.imfile.dims.index('C'),
  322. self.imfile.dims.index('Z'),
  323. self.imfile.dims.index('Y'),
  324. self.imfile.dims.index('X')],
  325. [0, 1, 2, 3])
  327. # index the last dimensions at 0
  328. for i in range(len(dims) - 4):
  329. self.im = self.im[..., 0]
  331. # convert im to f64
  332. self.im = self.im.astype(np.float64)
  334. # get the other info:
  335. if 'T' in dims: # timepoints
  336. # self.num_timepoints = dims['T'][1]
  337. # warnings.warn('this script throws away this info')
  338. pass
  339. if 'S' in dims: # scenes
  340. pass
  341. if 'B' in dims: # blocks
  342. pass
  343. if 'V' in dims:
  344. # The V-dimension ('view').
  345. pass
  346. if 'I' in dims:
  347. # The I-dimension ('illumination').
  348. pass
  349. if 'R' in dims:
  350. # The R-dimension ('rotation').
  351. pass
  352. if 'H' in dims:
  353. # The H-dimension ('phase').
  354. pass
  356. def load_lif(self):
  357. """
  358. load a lif file
  359. """
  361. # get the image
  362. if path.endswith('.lif'):
  363. self.imfile = LifFile(self.path)
  364. else:
  365. # Set color to red
  366. print('\033[91m', end='')
  367. print(f'Failed to process: {path}')
  368. # Reset color to default
  369. print('\033[0m', end='')
  370. return
  372. dims = self.imfile.image_list[0]
  374. if dims['dims'].x == 0 and dims['dims'].y == 0:
  375. return 'metadata_only'
  377. # get the number of channels, z_slices and shape
  378. self.num_channels = dims['channels']
  379. self.num_z_slices = dims['dims'].z
  380. self.width = dims['dims'].x
  381. self.height = dims['dims'].y
  383. # get scale
  384. self.scale = np.array(self.imfile.image_list[0]['scale'][0:3])
  385. if self.scale[2] == None:
  386. self.scale[2] = 0
  387. self.scale = self.scale[::-1] # xyz to zyx
  389. # load each image for mosaics
  390. if dims['dims'].m > 1:
  392. # Set color to red
  393. print('\033[91m', end='')
  394. print(f'Pete hasn''t implemened mosaics yet:')
  395. # Reset color to default
  396. print('\033[0m', end='')
  397. return
  399. # TBD additional checks
  400. if not 'M' in dims:
  401. raise ValueError('Mosaic image found, but no M dimension found')
  403. # TDB look at the size of im and cry if really large
  404. if (self.mosaic.nbytes / 1e9) > 5:
  405. self.big_image = True
  406. print(
  407. f'WARNING: Image size is {self.im.nbytes / 1e9} GB, this will cause memory issues')
  408. return
  410. # load each image for non-mosaics
  411. else:
  412. # create an empty array C-Z-Y-X
  413. self.im = np.zeros((self.num_channels, self.num_z_slices, self.height, self.width))
  414. for c in range(self.num_channels):
  415. for z in range(self.num_z_slices):
  416. self.im[c, z, :, :] = self.imfile.get_image(0).get_frame(z=z, t=0, c=c)
  418. # convert im to f64
  419. self.im = self.im.astype(np.float64)
  421. # get the other info:
  422. if dims['dims'].t > 1: # timepoints
  423. token = 'T'
  424. self.num_timepoints = dims['dims'].t
  425. warnings.warn(f'this script throws away this info: {token}')
  426. pass
  428. def extract_colors(self):
  430. if self.path.endswith('.lif'):
  431. self.metadata = xml_to_dict(self.imfile.xml_header)
  433. # not sure whats up with lif files, they dont seem to store laser or dye info?
  434. results = []
  435. def find_key(dictionary, target):
  436. for key, value in dictionary.items():
  437. if key == target:
  438. results.append(value)
  439. elif isinstance(value, dict):
  440. find_key(value, target)
  441. find_key(self.metadata, 'dye')
  442. find_key(self.metadata, 'color')
  443. find_key(self.metadata, 'laser')
  445. # assuming colors are in order blue to red
  446. self.colours = []
  447. self.dyes = []
  449. for c in range(self.num_channels):
  450. if c == 0:
  451. self.colours.append([0, 255, 255])
  452. self.dyes.append('cyan')
  453. elif c == 1:
  454. self.colours.append([255, 255, 0])
  455. self.dyes.append('yellow')
  456. elif c == 2:
  457. self.colours.append([255, 0, 0])
  458. self.dyes.append('red')
  459. elif c == 3:
  460. self.colours.append([255, 0, 255])
  461. self.dyes.append('magenta')
  462. elif c == 4:
  463. self.colours.append([255, 255, 255])
  464. self.dyes.append('white')
  466. elif self.path.endswith('.czi'):
  467. self.metadata = self.imfile.meta
  468. dyes = self.metadata.findall('.//DyeName')
  470. # looks like the first 3 distance/values are camera props?
  471. self.scale = np.array([float(self.metadata.findall('.//Distance/Value')[i].text) for i in range(3, 6)])[::-1]
  473. if len(dyes) != self.num_channels:
  474. warnings.warn('num channel != num dyes')
  475. return
  477. self.dyes = [None] * self.num_channels
  479. for c in range(self.num_channels):
  480. self.dyes[c] = dyes[c].text
  482. if 'DAPI' in self.dyes[c]\
  483. or 'dapi' in self.dyes[c] \
  484. or 'Hoechst 33342' in self.dyes[c] \
  485. or 'Hoechst 33258' in self.dyes[c]:
  486. self.colours.append([0, 255, 255])
  487. continue
  488. elif 'FITC' in self.dyes[c]:
  489. self.colours.append([255, 255, 0])
  490. continue
  491. elif 'Cy3' in self.dyes[c] or 'Rhodamine' in self.dyes[c]:
  492. self.colours.append([255, 0, 0])
  493. continue
  494. elif 'Cy5' in self.dyes[c]:
  495. self.colours.append([255, 0, 255])
  496. continue
  498. # extract all numbers from dye
  499. try:
  500. dye_nums = float(re.findall(r'\d+', self.dyes[c])[0])
  501. except:
  502. dye_nums = -1
  504. if dye_nums < 0:
  505. self.colours.append([255, 255, 255])
  506. elif dye_nums < 405:
  507. self.colours.append([0, 255, 255])
  508. elif dye_nums < 500:
  509. self.colours.append([255, 255, 0])
  510. elif dye_nums < 600:
  511. self.colours.append([255, 0, 0])
  512. elif dye_nums < 700:
  513. self.colours.append([255, 0, 255])
  514. else:
  515. self.colours.append([0, 0, 0])
  516. warnings.warn(f'no color found for {self.path}; channel {c}, {self.dyes[c]}')
  518. def project_mip(self, side_projections=False, z_scale=1):
  519. """
  520. make a maximum intensity projection
  521. """
  522. # check for z slices
  523. if self.num_z_slices == 1:
  525. print('\033[96m', end='')
  526. print(f'no z slices found in {self.path} returning')
  527. print('\033[0m', end='')
  528. self.mip = np.zeros((self.num_channels,
  529. self.im.shape[2],
  530. self.im.shape[3]))
  531. for c in range(self.num_channels):
  532. self.mip[c, :, :] = self.im[c, 0, :, :]
  533. return
  535. # initialize the mip
  536. if side_projections:
  538. if not self.big_image:
  539. self.mip = np.zeros((self.num_channels,
  540. self.im.shape[2] + self.im.shape[1] * z_scale + 1,
  541. self.im.shape[3] + self.im.shape[1] * z_scale + 1))
  543. for c in range(self.num_channels):
  544. # check for z slices
  545. self.mip[c,
  546. 0:self.im.shape[2],
  547. 0:self.im.shape[3]] = np.max(self.im[c, :, :, :], axis=0)
  549. projection_yz = np.max(self.im[c, :, :, :], axis=1)
  550. projection_yz = zoom(projection_yz, (z_scale, 1))
  551. self.mip[c,
  552. (self.im.shape[2] + 1):(self.im.shape[2] + 1 + self.im.shape[1] * z_scale),
  553. 0:self.im.shape[3]] = projection_yz
  555. projection_xz = np.max(self.im[c, :, :, :], axis=2).T
  556. projection_xz = zoom(projection_xz, (1, z_scale))
  557. self.mip[c,
  558. 0:self.im.shape[2],
  559. (self.im.shape[3] + 1):(self.im.shape[3] + 1 + self.im.shape[1] * z_scale)] = projection_xz
  560. return
  562. if self.big_image:
  564. self.mip = np.zeros((self.num_channels,
  565. self.height + self.num_z_slices * z_scale + 1,
  566. self.width + self.num_z_slices * z_scale + 1))
  568. for m in tqdm(range(self.num_mosaics), desc=f'Generating mip for *big image*:'):
  569. if m % (self.num_mosaics // 10) == 0:
  570. print(f'.', end='')
  572. for c in range(self.num_channels):
  573. self.mip[c,
  574. self.bbox[m, 1]:self.bbox[m, 1] + self.bbox[m, 3],
  575. self.bbox[m, 0]:self.bbox[m, 0] + self.bbox[m, 2]] = np.max(self.mosaic[c, :, :, :, m], axis=0)
  578. projection_yz = np.max(self.mosaic[c, :, :, :, m], axis=1)
  579. projection_yz = zoom(projection_yz, (z_scale, 1))
  580. self.mip[c,
  581. -(self.num_z_slices * z_scale + 1):-1,
  582. self.bbox[m, 0]:self.bbox[m, 0] + self.bbox[m, 2]] = projection_yz
  584. projection_xz = np.max(self.mosaic[c, :, :, :, m], axis=2).T
  585. projection_xz = zoom(projection_xz, (1, z_scale))
  586. self.mip[c,
  587. self.bbox[m, 1]:self.bbox[m, 1] + self.bbox[m, 3],
  588. -(self.num_z_slices * z_scale + 1):-1,] = projection_xz
  589. return
  591. else:
  592. if not self.big_image:
  593. self.mip = np.zeros((self.num_channels,
  594. self.im.shape[2],
  595. self.im.shape[3]))
  597. for c in range(self.num_channels):
  598. self.mip[c, :, :] = np.max(self.im[c, :, :, :], axis=0)
  600. return
  602. if self.big_image:
  603. self.mip = np.zeros((self.num_channels,
  604. self.height + 1,
  605. self.width + 1))
  607. for m in tqdm(range(self.num_mosaics), desc=f'Generating mip for *big image*:'):
  608. for c in range(self.num_channels):
  609. self.mip[c,
  610. self.bbox[m, 1]:self.bbox[m, 1] + self.bbox[m, 3],
  611. self.bbox[m, 0]:self.bbox[m, 0] + self.bbox[m, 2]] = np.max(self.mosaic[c, :, :, :, m], axis=0)
  615. def normalize(self, max=False, gamma=1):
  616. """
  617. modifies '.mip' normalizing the image
  618. """
  619. #if self.mip == [0, 0]:
  620. if np.all(self.mip == 0):
  621. print('No mip to normalize')
  622. return
  624. self.nmip = np.zeros((self.num_channels, self.mip.shape[2], self.mip.shape[1]))
  626. for c in range(self.num_channels):
  628. if max:
  629. mip = (self.mip[c, :, :] - np.nanmin(self.mip[c, :, :])) / \
  630. (np.nanmax(self.mip[c, :, :]) - np.nanmin(self.mip[c, :, :]))
  631. else:
  632. mip = self.mip[c, :, :] - np.nanmin(self.mip[c, :, :])
  633. if np.nansum(mip) != 0:
  634. mip_p = np.percentile(mip, 99.8)
  635. mip[mip > mip_p] = mip_p
  636. mip = mip/mip_p
  638. if gamma != 1:
  639. mip = mip ** gamma
  641. self.nmip[c, :, :] = mip * 255
  643. def save(self,
  644. save_path,
  645. save_mip_channels,
  646. save_mip_panel,
  647. save_mip_merge,
  648. save_dye_overlaid,
  649. save_colors):
  651. #if self.mip == [0, 0]:
  652. if np.all(self.mip == 0):
  653. print('No mip to save')
  654. return
  656. cwd = os.getcwd()
  657. try:
  658. os.chdir(os.path.dirname(self.path))
  659. except:
  660. os.mkdir(os.path.dirname(self.path))
  661. os.chdir(os.path.dirname(self.path))
  663. if self.big_image:
  664. optimize = False
  665. else:
  666. optimize = True
  668. file_stem = os.path.splitext(os.path.basename(self.path))[0]
  670. for c in range(self.num_channels):
  671. # PIL on each channel
  672. mip = Image.fromarray(self.mip[c, :, :])
  673. mip = mip.convert('L')
  674. base = np.ceil(self.num_channels ** 0.5).astype('int')
  676. if save_colors and len(self.colours[c]) > 0:
  677. mip = ImageOps.colorize(mip, (0, 0, 0), tuple(self.colours[c]))
  678. else:
  679. mip = mip.convert('RGB')
  681. if save_dye_overlaid:
  682. font_color = tuple(self.colours[c])
  683. font_size = self.height // 50
  684. draw = ImageDraw.Draw(mip)
  685. if platform == 'linux' or platform == 'linux2' or platform == 'darwin':
  686. text_overlay = [[]]
  687. text_overlay.append(c * ['\n'])
  688. text_overlay.append([self.dyes[c]])
  689. text_overlay = ''.join([item for sublist in text_overlay for item in sublist])
  690. draw.text((0, 0), text_overlay,
  691. font_color,
  692. ImageFont.truetype('Arial.ttf', size=font_size))
  693. elif platform == 'win32':
  694. draw.text((0, 0), self.dyes[c],
  695. font_color,
  696. ImageFont.truetype('arial.ttf', size=font_size))
  698. # create an image of all 'c' merged
  699. if save_mip_merge or \
  700. save_mip_panel and self.num_channels > 1 and self.num_channels < base ** 2:
  701. if c == 0:
  702. self.mip_merge = mip.copy()
  703. else:
  704. self.mip_merge = Image.merge('RGB', (
  705. ImageChops.add(self.mip_merge.getchannel('R'), mip.getchannel('R')),
  706. ImageChops.add(self.mip_merge.getchannel('G'), mip.getchannel('G')),
  707. ImageChops.add(self.mip_merge.getchannel('B'), mip.getchannel('B'))))
  710. if c == 0:
  711. self.mip_panel = np.zeros((mip.height * base, mip.width * base, 3))
  713. self.mip_panel[c % base * mip.height:(c % base + 1) * mip.height,
  714. c // base * mip.width:(c // base + 1) * mip.width,
  715. :] = np.array(mip).copy()
  717. # save
  718. if save_mip_channels:
  719. # mip.save(f'{file_stem}_ch{c}_.png', optimize=optimize)
  720. cv2.imwrite(f'{file_stem}_ch{c}_.png', cv2.cvtColor(np.array(mip), cv2.COLOR_RGB2BGR))
  722. # save merged images
  723. if save_mip_merge:
  724. # self.mip_merge.save(f'{file_stem}_merge.png', optimize=optimize)
  725. cv2.imwrite(f'{file_stem}_merge.png', cv2.cvtColor(np.array(self.mip_merge), cv2.COLOR_RGB2BGR))
  727. # save panel images
  728. if save_mip_panel and self.num_channels > 1:
  729. # add the merge to the panel if there is space
  730. if self.num_channels < base ** 2:
  731. self.mip_panel[self.num_channels % base * mip.height:(self.num_channels % base + 1) * mip.height,
  732. self.num_channels // base * mip.width:(self.num_channels // base + 1) * mip.width,
  733. :] \
  734. = np.array(self.mip_merge).copy()
  736. # remove black space
  737. self.mip_panel = self.mip_panel[~np.all(self.mip_panel == 0, axis=(1, 2))]
  739. # save mip panel cv2 (is much faster)
  740. cv2.imwrite(f'{file_stem}_panel.png',
  741. cv2.cvtColor(self.mip_panel.astype('uint8'), cv2.COLOR_RGB2BGR))
  743. print(f'converted {file_stem} and saved')
  744. os.chdir(cwd)
  746. def combine_big_image_masks(self, mask):
  748. mask = np.transpose(mask, (2, 1, 0))
  750. # define mosaic bounds
  751. window_size = 200
  752. overlap = 100
  754. mask = mask[::-1]
  756. yl = np.hstack([0, np.arange(window_size - overlap, mask.shape[1], window_size)])
  757. yu = np.hstack([window_size, np.arange(window_size - overlap + window_size, mask.shape[1], window_size), mask.shape[1]])
  759. xl = np.hstack([0, np.arange(window_size - overlap, mask.shape[2], window_size)])
  760. xu = np.hstack([window_size, np.arange(window_size - overlap + window_size, mask.shape[2], window_size), mask.shape[2]])
  762. # process a mosaic of the areas (speeds up processing significantly due to morphological ops)
  763. my = np.vstack([yl, yu]).T
  764. mx = np.vstack([xl, xu]).T
  766. mosaic = product(my, mx)
  768. if not np.any(mask):
  769. print(f'\033[94mError: {self.path} has no labels\033[0m')
  770. return
  772. combine_threshold = 0.7
  774. for nm, m in enumerate(mosaic):
  776. # get the mask for this mosaic
  777. vol = mask[:, m[1][0]:m[1][1], m[0][0]:m[0][1]]
  779. for nz in range(1, vol.shape[0]):
  781. slice_j = vol[nz, :, :]
  782. slice_i = vol[nz - 1, :, :]
  784. # # get id for slices
  785. # slice_j_labels = np.unique(slice_j)
  786. # slice_i_labels = np.unique(slice_i)
  788. check_labels_mask = slice_i - slice_j < 0
  789. # check_labels_j = slice_j_labels * check_labels_mask
  790. # check_labels_i = slice_i_labels * check_labels_mask
  791. check_labels_j = slice_j * check_labels_mask
  792. check_labels_i = slice_i * check_labels_mask
  794. uni_slice_j = np.unique(check_labels_j)
  795. uni_slice_i = np.unique(check_labels_i)
  796. uni_slice_j = uni_slice_j[uni_slice_j != 0]
  797. uni_slice_i = uni_slice_i[uni_slice_i != 0]
  799. # check that theres something in both slices
  800. if reduction(uni_slice_j, np.logical_or, 'any', None, None, None) \
  801. and reduction(uni_slice_i, np.logical_or, 'any', None, None, None):
  803. for j in uni_slice_j:
  804. for i in uni_slice_i:
  805. img_j = np.array(slice_j == j)
  806. img_i = np.array(slice_i == i)
  807. img_ij = np.logical_and(img_i, img_j)
  808. sum_img_j = img_j.sum()
  809. if sum_img_j > 2000: # remove the object if its got a really big 2D size note doesnt work for slice 0 objects
  810. slice_j[slice_j == j] = 0
  811. changed = True
  812. elif reduction(img_ij, np.logical_or, 'any', None, None, None):
  813. # if an object on adjacent layers has an intersection > 'combine_threshold' make them the same
  814. sum_img_i = img_i.sum()
  815. sum_img_ij = img_ij.sum()
  816. if sum_img_ij / sum_img_i > combine_threshold or sum_img_ij / sum_img_j > combine_threshold:
  817. slice_j[slice_j == j] = i
  818. changed = True
  820. if changed:
  821. mask[nz, m[1][0]:m[1][1], m[0][0]:m[0][1]] = slice_j
  823. # condense the mask
  824. mask = np.max(mask, axis=0)
  826. # convert back to xy
  827. mask = np.transpose(mask, (1, 0))
  829. return mask
  831. def process_2d_mask(self):
  833. print('processing 2D mask...')
  835. # process vars
  836. count = 0
  837. try:
  838. SO.channels_of_interest_vars[0].get()
  839. ch_of_interest = [i.get() for i in SO.channels_of_interest_vars]
  840. except:
  841. ch_of_interest = [i for i in SO.channels_of_interest_vars]
  843. self.mask_props = MaskProperties2D()
  845. if not len(self.mask.shape) == 2:
  846. print(f'\033[94mError: {self.path} isn''t 2D?\033[0m')
  847. return
  849. # rescale image to make yx of an pixel the same, then 1 µm, or if scale < 1 µm, scale.min()
  850. min_scale = np.min(np.hstack([self.scale[1::], 1]))
  851. zoom_by = self.scale[1::] / min_scale
  853. im = np.zeros(np.hstack([self.num_channels, (np.array(self.mip.shape[1::]) * zoom_by).astype('int')]))
  854. for c in range(self.num_channels):
  855. im[c, :, :] = zoom(np.squeeze(self.mip[c, :, :]), zoom_by, order=1)
  857. mask = zoom(self.mask, zoom_by, order=0)
  859. # define mosaic bounds
  860. window_size = 200
  861. overlap = 100
  863. yl = np.hstack([0, np.arange(window_size - overlap, im.shape[1], window_size)])
  864. yu = np.hstack([window_size, np.arange(window_size - overlap + window_size, im.shape[1], window_size), im.shape[1]])
  867. xl = np.hstack([0, np.arange(window_size - overlap, im.shape[2], window_size)])
  868. xu = np.hstack([window_size, np.arange(window_size - overlap + window_size, im.shape[2], window_size), im.shape[2]])
  870. # process a mosaic of the areas (speeds up processing significantly due to morphological ops)
  871. my = np.vstack([yl, yu]).T
  872. mx = np.vstack([xl, xu]).T
  874. mosaic = product(my, mx)
  876. if not np.any(mask):
  877. print(f'\033[94mError: {self.path} has no labels\033[0m')
  878. return
  880. mask_id_processed = np.array([0])
  882. for nm, m in enumerate(mosaic):
  884. # get the mask for this mosaic
  885. area = mask[m[1][0]:m[1][1], m[0][0]:m[0][1]]
  886. area_im = im[:, m[1][0]:m[1][1], m[0][0]:m[0][1]]
  888. # if there are no labels in this area, skip
  889. if not np.any(area):
  890. continue
  892. # remove mask ids that have already been processed
  893. area_id = np.unique(area)
  895. # if area_id is in mask_id_processed, remove it
  896. for i in np.intersect1d(area_id, mask_id_processed):
  897. area[area == i] = 0
  899. area_id = np.unique(area)
  900. area_id = area_id[area_id != 0]
  902. rp = regionprops(area)
  904. for rn, r in enumerate(rp):
  905. # filter out large & small objects
  906. if r.area < 10 or r.area > 10_000:
  907. continue
  909. # save properties
  910. self.mask_props.id = np.hstack((self.mask_props.id, area_id[rn]))
  911. self.mask_props.area = np.hstack((self.mask_props.area, r.area))
  912. self.mask_props.centroid = np.vstack((self.mask_props.centroid, np.array(r.centroid) + np.array([m[1][0], m[0][0]])))
  913. self.mask_props.perimeter = np.hstack((self.mask_props.perimeter, r.perimeter))
  914. self.mask_props.form_factor = np.hstack((self.mask_props.form_factor, r.perimeter ** 2 / r.area))
  915. self.mask_props.minor_ax = np.hstack((self.mask_props.minor_ax, r.minor_axis_length))
  916. self.mask_props.major_ax = np.hstack((self.mask_props.major_ax, r.major_axis_length))
  917. self.mask_props.eccentricity = np.hstack((self.mask_props.eccentricity, r.eccentricity))
  918. self.mask_props.convexity = np.hstack((self.mask_props.convexity, r.convex_area / r.area))
  919. self.mask_props.orientation = np.hstack((self.mask_props.orientation, r.orientation))
  921. # saturation intensity in mask of the other channels
  922. tf_sat = np.hstack([
  923. np.mean(area_im[c][r.coords[:, 0], r.coords[:, 1]])
  924. for c in range(self.num_channels)
  925. ])
  927. if count == 0:
  928. self.mask_props.tf_sat = tf_sat
  929. else:
  930. self.mask_props.tf_sat = np.vstack((self.mask_props.tf_sat, tf_sat))
  932. count += 1
  934. # add all area_id to mask_id_processed
  935. mask_id_processed = np.hstack([area_id, mask_id_processed])
  937. # calculate distance of each cell in mask from edge of cell mass
  938. print('Calculating distances of cells from edge of cell mass...')
  941. # cellpose_model = models.Cellpose(gpu=True, model_type='nuclei')
  942. # nuc_mask = cellpose_model.eval(
  943. # self.nmip[nuclear_channel].astype(np.uint8),
  944. # diameter=diam,
  945. # flow_threshold=flow_threshold,
  946. # cellprob_threshold=cellprob_threshold)[0]
  947. # # region props centroids
  948. # properties = regionprops(label(nuc_mask))
  949. # centroids = np.array([prop.centroid for prop in properties]).astype(np.int64)
  950. #
  951. # threshold = 1
  952. # cell_mass = (nuc_mask > 0 * (threshold + 1)).astype(np.float64)
  953. # tri_upper_ind = np.triu_indices(centroids.shape[0], k=1)
  954. # centroid_combinations = centroids[np.array(tri_upper_ind)]
  955. #
  956. # # thin out centroid combinations
  957. # dist = centroid_combinations[0, :, :] - centroid_combinations[1, :, :]
  958. # dist = (dist[:, 0] ** 2 + dist[:, 1] ** 2) ** 0.5
  959. # dist = dist < cell_mass.shape[1] / 2
  960. # centroid_combinations = centroid_combinations[:, dist, :]
  961. #
  962. # z = np.zeros_like(cell_mass).astype(np.float64)
  963. # for c1, c2 in tqdm(centroid_combinations.transpose((1, 0, 2)), total=centroid_combinations.shape[1]):
  964. # temp = z.copy()
  965. # cell_mass += cv2.line(temp, c1[::-1], c2[::-1], (1,), 5).astype(np.float64) / centroid_combinations.shape[1]
  966. #
  968. combo = self.nmip.astype(np.float64)
  969. combo = combo.sum(axis=0)
  970. combo = combo / combo.max() * 255
  971. combo = combo.astype(np.uint8)
  972. # bw = 255 - cv2.adaptiveThreshold(combo, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 5)
  974. combo = cv2.medianBlur(combo, 33)
  975. th, _ = cv2.threshold(combo, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
  976. bw = combo > (th * 0.33)
  977. bw = np.pad(bw, 2, 'constant', constant_values=255)
  978. bw[0:2,0:2] = 0
  979. bw[0:2,-3:-1] = 0
  980. bw[-3:-1,0:2] = 0
  981. bw[-3:-1,-3:-1] = 0
  982. bw = bw > 0
  983. bw = binary_fill_holes(bw)
  984. bw = bw[2:-2, 2:-2]
  985. diam = np.mean(self.mask_props.area) + 3 * np.std(self.mask_props.area)
  986. bw = morphology.remove_small_objects(bw, int(3 * (diam/2)**2))
  988. # calculate distance of each mask from the edge of the cell mass
  989. self.mask_props.dist_from_edge = np.zeros(self.mask_props.id.shape[0])
  990. dist_transform = distance_transform_edt(bw)
  991. for n, i in enumerate(self.mask_props.id):
  992. obj = (mask == i)
  993. if obj.sum() == 0:
  994. continue
  995. mean_distance = np.nanmean(dist_transform[obj])
  996. if np.isfinite(mean_distance):
  997. self.mask_props.dist_from_edge[n] = mean_distance
  998. else:
  999. self.mask_props.dist_from_edge[n] = -1
  1001. if np.isnan(self.mask_props.dist_from_edge).any():
  1002. print('tell pete, there shouldn''t be nans in the dist from edge')
  1004. fig, ax = plt.subplots(1, 3, figsize=(15, 5))
  1005. ax[0].imshow(im.transpose((1, 2, 0)))
  1006. ax[1].imshow(bw * 255)
  1007. cell_mass_im = im[0, :, :] / 2 + bw.astype(np.uint8) * 255 / 2
  1008. ax[2].imshow(cell_mass_im)
  1009. ax[2].scatter(self.mask_props.centroid[:, 1],
  1010. self.mask_props.centroid[:, 0],
  1011. c='r',
  1012. s=self.mask_props.dist_from_edge / 50)
  1014. self.cell_mass = cell_mass_im
  1016. def process_3d_mask(self):
  1018. print('processing 3D mask...')
  1020. # process vars
  1021. count = 0
  1022. try:
  1023. SO.channels_of_interest_vars[0].get()
  1024. ch_of_interest = [i.get() for i in SO.channels_of_interest_vars]
  1025. except:
  1026. ch_of_interest = [i for i in SO.channels_of_interest_vars]
  1028. self.mask_props = MaskProperties3D()
  1030. if not len(self.mask.shape) == 3:
  1031. print(f'\033[94mError: {self.path} isn''t 3D?\033[0m')
  1032. return
  1034. # rescale image to make xyz of a voxel the same, then 1 µm, or if scale < 1 µm, scale.min()
  1035. min_scale = np.min(np.hstack([self.scale[1::], 1]))
  1036. zoom_by = self.scale / min_scale
  1038. im = np.zeros(np.hstack([self.num_channels, np.round((np.array(self.mask.shape) * zoom_by)).astype('int')]))
  1039. for c in range(self.num_channels):
  1040. im[c, :, :, :] = zoom(self.im[c, :, :, :], zoom_by, order=1)
  1042. mask = zoom(self.mask, zoom_by, order=0)
  1044. # define mosaic bounds
  1045. window_size = 200
  1046. overlap = 100
  1048. zl = np.hstack([0, np.arange(window_size - overlap, im.shape[0], window_size)])
  1049. zu = np.hstack([window_size, np.arange(window_size - overlap + window_size, im.shape[0], window_size), im.shape[0]])
  1051. yl = np.hstack([0, np.arange(window_size - overlap, im.shape[1], window_size)])
  1052. yu = np.hstack([window_size, np.arange(window_size - overlap + window_size, im.shape[1], window_size), im.shape[1]])
  1054. xl = np.hstack([0, np.arange(window_size - overlap, im.shape[2], window_size)])
  1055. xu = np.hstack([window_size, np.arange(window_size - overlap + window_size, im.shape[2], window_size), im.shape[2]])
  1057. # process a mosaic of the areas (speeds up processing significantly due to morphological ops)
  1058. mz = np.vstack([zl, zu]).T
  1059. my = np.vstack([yl, yu]).T
  1060. mx = np.vstack([xl, xu]).T
  1062. mosaic = product(mz, my, mx)
  1064. if not np.any(mask):
  1065. print(f'\033[94mError: {self.path} has no labels\033[0m')
  1066. return
  1068. mask_id_processed = np.array([0])
  1070. combine_threshold = 0.7
  1072. for nm, m in enumerate(mosaic):
  1074. # get the mask for this mosaic
  1075. vol = mask[:, m[1][0]:m[1][1], m[0][0]:m[0][1]]
  1077. for nz in range(1, vol.shape[0]):
  1079. slice_j = vol[nz, :, :]
  1080. slice_i = vol[nz - 1, :, :]
  1082. # get id for slices
  1083. slice_j_labels = np.unique(slice_j)
  1084. slice_i_labels = np.unique(slice_i)
  1086. check_labels_mask = slice_i - slice_j < 0
  1087. check_labels_j = slice_j_labels * check_labels_mask
  1088. check_labels_i = slice_i_labels * check_labels_mask
  1090. uni_slice_j = np.unique(check_labels_j)
  1091. uni_slice_i = np.unique(check_labels_i)
  1092. uni_slice_j = uni_slice_j[uni_slice_j != 0]
  1093. uni_slice_i = uni_slice_i[uni_slice_i != 0]
  1095. # check that theres something in both slices
  1096. if reduction(uni_slice_j, np.logical_or, 'any', None, None, None) \
  1097. and reduction(uni_slice_i, np.logical_or, 'any', None, None, None):
  1099. for j in uni_slice_j:
  1100. for i in uni_slice_i:
  1101. img_j = np.array(slice_j == j)
  1102. img_i = np.array(slice_i == i)
  1103. img_ij = np.logical_and(img_i, img_j)
  1104. sum_img_j = img_j.sum()
  1105. if sum_img_j > 2000: # remove the object if its got a really big 2D size note doesnt work for slice 0 objects
  1106. slice_j[slice_j == j] = 0
  1107. changed = True
  1108. elif reduction(img_ij, np.logical_or, 'any', None, None, None):
  1109. # if an object on adjacent layers has an intersection > 'combine_threshold' make them the same
  1110. sum_img_i = img_i.sum()
  1111. sum_img_ij = img_ij.sum()
  1112. if sum_img_ij / sum_img_i > combine_threshold or sum_img_ij / sum_img_j > combine_threshold:
  1113. slice_j[slice_j == j] = i
  1114. changed = True
  1116. if changed:
  1117. mask[nz, m[1][0]:m[1][1], m[0][0]:m[0][1]] = slice_j
  1119. for nm, m in enumerate(mosaic):
  1121. # get the mask for this mosaic
  1122. vol = mask[m[2][0]:m[2][1], m[1][0]:m[1][1], m[0][0]:m[0][1]]
  1123. vol_im = im[:, m[2][0]:m[2][1], m[1][0]:m[1][1], m[0][0]:m[0][1]]
  1125. # if there are no labels in this area, skip
  1126. if not np.any(vol):
  1127. continue
  1129. # remove mask ids that have already been processed
  1130. area_id = np.unique(vol)
  1132. # if area_id is in mask_id_processed, remove it
  1133. for i in np.intersect1d(area_id, mask_id_processed):
  1134. vol[vol == i] = 0
  1136. area_id = np.unique(vol)
  1137. area_id = area_id[area_id != 0]
  1139. rp = regionprops(vol)
  1141. for rn, r in enumerate(rp):
  1142. # filter out large & small objects
  1143. if r.area < 10 or r.area > 10_000:
  1144. continue
  1146. # save properties
  1147. self.mask_props.id = np.hstack((self.mask_props.id, area_id[rn]))
  1148. self.mask_props.volume = np.hstack((self.mask_props.volume, r.area))
  1149. self.mask_props.centroid = np.vstack((self.mask_props.centroid, np.array(r.centroid) + np.array([m[2][0], m[1][0], m[0][0]])))
  1150. self.mask_props.bounding_box = np.vstack((self.mask_props.bounding_box, r.bbox))
  1151. self.mask_props.form_factor = np.hstack((self.mask_props.form_factor, r.perimeter ** 2 / r.area))
  1152. self.mask_props.eccentricity = np.hstack((self.mask_props.eccentricity, r.eccentricity))
  1153. self.mask_props.orientation = np.hstack((self.mask_props.orientation, r.orientation))
  1155. # saturation intensity in mask of the other channels
  1156. tf_sat = np.hstack([
  1157. np.mean(vol_im[c][r.coords[:, 0], r.coords[:, 1], r.coords[:, 2]])
  1158. for c in range(self.num_channels)
  1159. ])
  1161. if count == 0:
  1162. self.mask_props.tf_sat = tf_sat
  1163. else:
  1164. self.mask_props.tf_sat = np.vstack((self.mask_props.tf_sat, tf_sat))
  1166. count += 1
  1168. # add all area_id to mask_id_processed
  1169. mask_id_processed = np.hstack([area_id, mask_id_processed])
  1171. def plot_2d_mask(self):
  1173. try:
  1174. SO.channels_of_interest_vars[0].get()
  1175. ch_of_interest = [i.get() for i in SO.channels_of_interest_vars]
  1176. except:
  1177. ch_of_interest = [i for i in SO.channels_of_interest_vars]
  1179. # with num_channel axes
  1180. fig, ax = plt.subplots(2,
  1181. np.max([sum(ch_of_interest) + 1, 3]),
  1182. figsize=(4 * np.max([3, sum(ch_of_interest) + 1]), 8))
  1184. for a in ax.flatten():
  1185. a.set_xticks([])
  1186. a.set_yticks([])
  1187. a.set_facecolor('black')
  1188. fig.set_facecolor('black')
  1190. x = self.mask_props.centroid[:,1]
  1191. y = self.mask_props.centroid[:,0]
  1193. if len(y) == 0:
  1194. return
  1196. colors = ['cyan', 'yellow', 'red', 'magenta', 'green']
  1197. for c in range(self.mask_props.tf_sat.shape[1]):
  1198. ax[0, c+1].scatter(x, y,
  1199. s=(self.mask_props.tf_sat[:, c] / self.mask_props.tf_sat[:, c].max()),
  1200. c=colors[c],
  1201. alpha=0.99)
  1203. # ax[1, 0].imshow(self.mip[self.mask_ch, :, :], cmap='hot')
  1204. # ax[1, 0].invert_yaxis()
  1205. # ax[1, 1].imshow(self.mask, cmap='hot')
  1206. # ax[1, 1].invert_yaxis()
  1208. # plt.tight_layout()
  1209. # plt.show()
  1211. def plot_3d_mask(self):
  1213. try:
  1214. SO.channels_of_interest_vars[0].get()
  1215. ch_of_interest = [i.get() for i in SO.channels_of_interest_vars]
  1216. except:
  1217. ch_of_interest = [i for i in SO.channels_of_interest_vars]
  1219. # Create PyVista plotter
  1220. plotter = pv.Plotter(shape=(1, sum(ch_of_interest) + 1),
  1221. window_size=(300 * (sum(ch_of_interest) + 1), 300))
  1222. plotter.set_background('black')
  1224. # Get centroids and properties
  1225. x = self.mask_props.centroid[:, 0]
  1226. y = self.mask_props.centroid[:, 1]
  1227. z = self.mask_props.centroid[:, 2]
  1228. centroids = np.column_stack((x, y, z))
  1230. # Create glyph source
  1231. glyph_source = pv.PolyData(centroids)
  1233. # Add mask saturation glyphs
  1234. if self.mask_props.mask_sat.size > 0:
  1235. mask_sat_scale = (self.mask_props.mask_sat / self.mask_props.mask_sat.max())
  1236. else:
  1237. mask_sat_scale = np.array([])
  1239. plotter.subplot(0, 0)
  1240. plotter.add_glyph(glyph_source, scale=mask_sat_scale, color='white', render_points_as_spheres=True)
  1241. plotter.add_title("Mask Saturation", color='white')
  1243. # Add glyphs for other channels
  1244. colors = ['cyan', 'yellow', 'red', 'magenta', 'green']
  1245. for c in range(self.mask_props.tf_sat.shape[1]):
  1246. if self.mask_props.tf_sat[:, c].size > 0:
  1247. tf_sat_scale = (self.mask_props.tf_sat[:, c] / self.mask_props.tf_sat[:, c].max())
  1248. else:
  1249. tf_sat_scale = np.array([])
  1251. plotter.subplot(0, c + 1)
  1252. plotter.add_glyph(glyph_source, scale=tf_sat_scale, color=colors[c], render_points_as_spheres=True)
  1253. plotter.add_title(f"Ch of Int Sat {c}", color='white')
  1255. # Show the plot
  1256. plotter.show()
  1258. def save_2d_mask(self, po):
  1260. print(f'saving segmentation results{self.path}')
  1262. if not os.path.exists(po.save_path):
  1263. os.mkdir(po.save_path)
  1265. os.chdir(po.save_path)
  1266. file_stem = os.path.basename(self.path)
  1268. if self.big_image:
  1269. optimize = False
  1270. else:
  1271. optimize = True
  1273. # save mask image
  1274. mask = self.mask.astype('uint16')
  1276. # gray to rgb
  1277. mask_color = np.zeros((mask.shape[0], mask.shape[1], 3)).astype('uint8')
  1279. # loop through mask for each object and make it a random color
  1280. for c in range(3):
  1281. mask_c = mask
  1282. for i in range(1, mask.max()):
  1283. mask_c[mask_c == i] = 30 + np.random.randint(0, 255 - 30)
  1285. mask_color[:, :, c] = mask_c
  1287. # save images
  1288. try: #if cellmass is empty this will avoid crash
  1290. cv2.imwrite(f'{file_stem}_masks.png', cv2.cvtColor(np.array(mask), cv2.COLOR_GRAY2BGR))
  1291. cv2.imwrite(f'{file_stem}_masks_color.png', mask_color)
  1292. cv2.imwrite(f'{file_stem}_cell_mass.png', self.cell_mass)
  1294. except:
  1295. pass
  1297. # save data as csv
  1298. with open(file_stem + '_2Dresults.csv', 'w') as f:
  1299. # column names
  1300. var = 'id,' \
  1301. 'area,' \
  1302. 'centroid_x,' \
  1303. 'centroid_y,' \
  1304. 'perimeter,' \
  1305. 'form_factor,' \
  1306. 'minor_ax,' \
  1307. 'major_ax,' \
  1308. 'eccentricity,' \
  1309. 'convexity,' \
  1310. 'orientation,' \
  1311. 'dist_from_edge'
  1312. tf = ''
  1313. try:
  1314. SO.channels_of_interest_vars[0].get()
  1315. for i in range(sum([i.get() for i in SO.channels_of_interest_vars])):
  1316. tf += f',ch_of_int_sat{i}'
  1317. except:
  1318. for i in range(sum([i for i in SO.channels_of_interest_vars])):
  1319. tf += f',ch_of_int_sat{i}'
  1321. var = var + tf + '\n'
  1323. # write column names
  1324. f.write(var)
  1326. for i in range(self.mask_props.id.size):
  1330. # write row
  1331. tf = ''
  1333. #skip if tf_sat is empty w/ print error
  1334. if len(self.mask_props.tf_sat.shape) < 2 or self.mask_props.tf_sat.shape[1] == 0:
  1335. print("tf_sat is not 2D or the second dimension is empty.")
  1336. return
  1338. for c in range(self.mask_props.tf_sat.shape[1]):
  1339. tf += f',{self.mask_props.tf_sat[i, c]}'
  1340. f.write(f'{self.mask_props.id[i]},'
  1341. f'{self.mask_props.area[i]},'
  1342. f'{self.mask_props.centroid[i, 0]},'
  1343. f'{self.mask_props.centroid[i, 1]},'
  1344. f'{self.mask_props.perimeter[i]},'
  1345. f'{self.mask_props.form_factor[i]},'
  1346. f'{self.mask_props.minor_ax[i]},'
  1347. f'{self.mask_props.major_ax[i]},'
  1348. f'{self.mask_props.eccentricity[i]},'
  1349. f'{self.mask_props.convexity[i]},'
  1350. f'{self.mask_props.orientation[i]},'
  1351. f'{self.mask_props.dist_from_edge[i]}' # <- shouldn't be a comma here
  1352. + tf + '\n')
  1354. def save_3d_mask(self, po):
  1356. print(f'saving segmentation results{self.path}')
  1358. if not os.path.exists(po.save_path):
  1359. os.mkdir(po.save_path)
  1361. os.chdir(po.save_path)
  1362. file_stem = os.path.basename(self.path)
  1364. if self.big_image:
  1365. optimize = False
  1366. else:
  1367. optimize = True
  1369. # save mask image
  1370. mask = Image.fromarray(np.max(self.mask.astype('uint16'), axis=0))
  1371. mask.save(f'{file_stem}_masks.png', optimize=optimize)
  1373. # save data as csv
  1374. with open(file_stem + '_3Dresults.csv', 'w') as f:
  1375. # column names
  1376. var = 'id,' \
  1377. 'volume,' \
  1378. 'centroid_x,' \
  1379. 'centroid_y,' \
  1380. 'centroid_z,' \
  1381. 'surface_area,' \
  1382. 'sphericity,' \
  1383. 'minor_ax,' \
  1384. 'major_ax,' \
  1385. 'least_ax,' \
  1386. 'eccentricity,' \
  1387. 'convexity,' \
  1388. 'orientation,' \
  1389. 'mask_sat,' \
  1390. 'tf_sat'
  1392. tf = ''
  1393. try:
  1394. SO.channels_of_interest_vars[0].get()
  1395. for i in range(sum([i.get() for i in SO.channels_of_interest_vars])):
  1396. tf += f',ch_of_int_sat{i}'
  1397. except:
  1398. for i in range(sum([i for i in SO.channels_of_interest_vars])):
  1399. tf += f',ch_of_int_sat{i}'
  1402. var = var + tf + '\n'
  1404. # write column names
  1405. f.write(var)
  1407. for i in range(self.mask_props.id.size):
  1408. # write row
  1409. tf = ''
  1410. for c in range(self.mask_props.tf_sat.shape[1]):
  1411. tf += f',{self.mask_props.tf_sat[i, c]}'
  1412. f.write(f'{self.mask_props.id[i]},'
  1413. f'{self.mask_props.volume[i]},'
  1414. f'{self.mask_props.centroid[i, 0]},'
  1415. f'{self.mask_props.centroid[i, 1]},'
  1416. f'{self.mask_props.centroid[i, 2]},'
  1417. f'{self.mask_props.surface_area[i]},'
  1418. f'{self.mask_props.sphericity[i]},'
  1419. f'{self.mask_props.minor_ax[i]},'
  1420. f'{self.mask_props.major_ax[i]},'
  1421. f'{self.mask_props.least_ax[i]},'
  1422. f'{self.mask_props.eccentricity[i]},'
  1423. f'{self.mask_props.convexity[i]},'
  1424. f'{self.mask_props.orientation[i]},'
  1425. f'{self.mask_props.mask_sat[i]}' + tf + '\n')
  1428. # @attr.s(auto_attribs=True, auto_detect=True)
  1429. class MainGUI(tk.Tk):
  1430. """
  1431. Create a tkinter window to select options:
  1432. - select a folder to search for czi files
  1433. - select check boxes for:
  1434. - side projections (w/ side project scaling)
  1435. - gamma correction
  1436. - save mip channels
  1437. - save mip panel
  1438. - save mip merge
  1439. - save dye overlaid
  1440. - save colors
  1441. - use multiprocessing
  1442. - select a folder to save the images to
  1443. """
  1445. def __init__(self):
  1446. # create a tkinter window
  1447. self.root = tk.Tk()
  1448. self.root.title(' ')
  1450. # initalize variables
  1451. self.search_path = tk.StringVar()
  1452. # self.search_path.set('.set/search/path')
  1453. self.search_path.set('/Users/peternewman/Desktop/im/ben')
  1454. self.save_path = tk.StringVar()
  1455. # self.save_path.set('.set/save/path')
  1456. self.save_path.set('/Users/peternewman/Desktop/im/ben')
  1458. # establish a scale factor
  1459. s = 1.0
  1461. w = int(420 * s)
  1462. h = int(250 * s)
  1464. # size the window
  1465. self.root.minsize(w, h)
  1466. self.root.maxsize(w, h)
  1467. self.root.geometry(f'{w}x{h}')
  1469. # add a title
  1470. tk.Label(self.root, text='czi2png', font=('Arial', 25))\
  1471. .place(relx=10 / w, rely=10 / h) # width=135/w, height=36/h)
  1473. # # add search and save path buttons
  1474. tk.Button(self.root, text='Search Path', command=self.specify_search_path,
  1475. width=8, height=1).place(relx=10 / w, rely=53 / h)
  1476. tk.Button(self.root, text='Save Path', command=self.specify_save_path,
  1477. width=8, height=1).place(relx=10 / w, rely=83 / h)
  1479. self.search_path_label = tk.Label(self.root, textvariable=self.search_path, font=('Arial', 12), fg='gray')\
  1480. .place(relx=124 / w, rely=58 / h) # width=135/w, height=36/h)
  1481. self.save_path_label = tk.Label(self.root, textvariable=self.save_path, font=('Arial', 12), fg='gray') \
  1482. .place(relx=124 / w, rely=88 / h) # width=135/w, height=36/h)
  1484. # add check box for file type czi, lif or tif
  1485. self.file_type = tk.StringVar()
  1486. self.file_type.set('czi')
  1487. tk.Radiobutton(self.root, text='czi', variable=self.file_type,
  1488. value='czi') \
  1489. .place(relx=10 / w, rely=140 / h)
  1490. tk.Radiobutton(self.root, text='lif', variable=self.file_type,
  1491. value='lif') \
  1492. .place(relx=80 / w, rely=140 / h)
  1493. tk.Radiobutton(self.root, text='tif', variable=self.file_type,
  1494. value='tif') \
  1495. .place(relx=150 / w, rely=140 / h)
  1497. # # add a button to run the program
  1498. tk.Button(self.root, text='Convert 2 png!', command=self.main,
  1499. width=20, height=2).place(relx=10 / w, rely=180 / h)
  1501. # # add checkbox to save mip channels, mip panel, mip merge, dye overlaid, colors, multiprocessing
  1502. tk.Label(self.root, text='Options', font=('Arial', 12)) \
  1503. .place(relx=260 / w, rely=22 / h) # width=135/w, height=36/h)
  1505. self.save_mip_channels = tk.BooleanVar()
  1506. self.save_mip_channels.set(False)
  1507. tk.Checkbutton(self.root, text='save mip channels', command = self.display_input,
  1508. variable=self.save_mip_channels, onvalue=1, offvalue=0)\
  1509. .place(relx=260 / w, rely=53 / h)
  1511. self.save_mip_panel = tk.BooleanVar()
  1512. self.save_mip_panel.set(False)
  1513. tk.Checkbutton(self.root, text='save mip panel', command = self.display_input,
  1514. variable=self.save_mip_panel, onvalue=1, offvalue=0) \
  1515. .place(relx=260 / w, rely=80 / h)
  1517. self.save_mip_merge = tk.BooleanVar()
  1518. self.save_mip_merge.set(True)
  1519. tk.Checkbutton(self.root, text='save mip merge', command = self.display_input,
  1520. variable=self.save_mip_merge, onvalue=1, offvalue=0) \
  1521. .place(relx=260 / w, rely=107 / h)
  1523. self.save_dye_overlaid = tk.BooleanVar()
  1524. self.save_dye_overlaid.set(False)
  1525. tk.Checkbutton(self.root, text='save dye overlaid', command = self.display_input,
  1526. variable=self.save_dye_overlaid, onvalue=1, offvalue=0) \
  1527. .place(relx=260 / w, rely=133 / h)
  1529. self.save_colors = tk.BooleanVar()
  1530. self.save_colors.set(True)
  1531. tk.Checkbutton(self.root, text='save colors', command = self.display_input,
  1532. variable=self.save_colors, onvalue=1, offvalue=0) \
  1533. .place(relx=260 / w, rely=160 / h)
  1535. self.use_multiprocessing = tk.BooleanVar()
  1536. self.use_multiprocessing.set(False)
  1537. tk.Checkbutton(self.root, text='use multiprocessing', command = self.display_input,
  1538. variable=self.use_multiprocessing, onvalue=1, offvalue=0) \
  1539. .place(relx=260 / w, rely=186 / h)
  1541. self.segment_image = tk.BooleanVar()
  1542. self.segment_image.set(True)
  1543. tk.Checkbutton(self.root, text='segment image',
  1544. variable=self.segment_image, onvalue=1, offvalue=0) \
  1545. .place(relx=260 / w, rely=213 / h)
  1547. self.root.mainloop()
  1549. # debugging
  1550. def display_input(self):
  1551. print(f'search path: {self.search_path}')
  1552. print(f'save path: {self.save_path}')
  1553. print(f'save mip channels: {self.save_mip_channels.get()}')
  1554. print(f'save mip panel: {self.save_mip_panel.get()}')
  1555. print(f'save mip merge: {self.save_mip_merge.get()}')
  1556. print(f'save dye overlaid: {self.save_dye_overlaid.get()}')
  1557. print(f'save colors: {self.save_colors.get()}')
  1558. print(f'use multiprocessing: {self.use_multiprocessing.get()}')
  1560. def specify_search_path(self,):
  1561. self.search_path.set(tk.filedialog.askdirectory(parent=self.root, initialdir='/',
  1562. title='Please select a directory'))
  1564. def specify_save_path(self,):
  1565. self.save_path.set(tk.filedialog.askdirectory(parent=self.root, initialdir='/',
  1566. title='Please select a directory'))
  1568. def main(self):
  1569. try:
  1570. if self.search_path.get() == '.set/search/path' or self.save_path.get() == '.set/save/path':
  1571. tk.messagebox.showerror('Python Error', 'please select Search and Save paths * unassigned *')
  1572. return
  1574. if not os.path.isdir(self.search_path.get()) or not os.path.isdir(self.save_path.get()):
  1575. tk.messagebox.showerror('Python Error', 'Search and Save paths not directories')
  1576. return
  1578. # check that at least one save option is selected
  1579. if self.save_mip_channels.get() + self.save_mip_panel.get() + self.save_mip_merge.get() < 1:
  1580. tk.messagebox.showerror('Python Error', 'select at least channels, panel or merge image to save')
  1581. return
  1582. except:
  1583. print('incomplete error checks')
  1585. # set path of image files
  1586. search_path = self.search_path.get()
  1588. # get images
  1589. image_files = find_all_images_in_path(search_path, filetype=self.file_type.get())
  1590. all_process_files = [None] * len(image_files)
  1592. for n, image_file in enumerate(image_files):
  1593. po = ProcessOptions()
  1594. po.save_path = self.save_path.get()
  1595. po.save_mip_channels = self.save_mip_channels.get()
  1596. po.save_mip_panel = self.save_mip_panel.get()
  1597. po.save_mip_merge = self.save_mip_merge.get()
  1598. po.save_dye_overlaid = self.save_dye_overlaid.get()
  1599. po.save_colors = self.save_colors.get()
  1600. po.use_multiprocessing = self.use_multiprocessing.get()
  1601. po.segment_image = self.segment_image.get()
  1602. all_process_files[n] = po
  1603. all_process_files[n].image_path = image_file
  1605. self.root.destroy()
  1607. im_file_sizes = [os.path.getsize(image_file) for image_file in image_files]
  1608. cumulative_file_size = np.cumsum(im_file_sizes)
  1610. process_file(all_process_files[0])
  1612. # pop all_process_files[0] off the list
  1613. all_process_files.pop(0)
  1615. # time the function
  1616. start_time = time.perf_counter()
  1617. # run the processing routine on the czi images
  1618. if all_process_files[0].use_multiprocessing:
  1619. print(f'running multi processed: {image_files}')
  1620. with multiprocessing.Pool(multiprocessing.cpu_count()) as p:
  1621. p.map(process_file, all_process_files)
  1623. else:
  1624. print(f'running single threaded on: {image_files}')
  1625. for n, process_param in enumerate(all_process_files):
  1626. process_file(process_param)
  1628. # calculate time remaining use the files size to estimate processing time
  1629. time_remaining = (time.perf_counter() - start_time) / \
  1630. cumulative_file_size[n] * \
  1631. (cumulative_file_size[-1] -
  1632. cumulative_file_size[n])
  1633. # time taken
  1634. # per byte
  1635. # * bytes remaining
  1637. print(f'Time remaining: {time_remaining:0.2f} seconds')
  1639. # print the run time
  1640. print(
  1641. f'\nTime elapsed: {time.perf_counter() - start_time:0.2f} seconds')
  1643. # display a message box to indicate that the processing is complete
  1644. tk.messagebox.showinfo('Python Info', 'Images saved as png')
  1646. # close the window
  1647. self.root.destroy()
  1649. @attr.s(auto_attribs=True, auto_detect=True)
  1650. class SegmentationGUI:
  1651. def __init__(self, parent, image):
  1652. self.root = parent
  1653. self.root.title('Segmentation Options')
  1655. # the reason we are here
  1656. global SO
  1657. SO = SegmentationOptions()
  1659. window_size = (1500, 550)
  1660. self.root.geometry(f"{window_size[0]}x{window_size[1]}")
  1662. image.mip = np.array(image.mip)
  1663. self.image = image
  1665. self.mask_channel_var = tk.IntVar()
  1666. self.mask_channel_var.set(0)
  1667. SO.mask_channel_var = self.mask_channel_var.get()
  1669. self.cyto_var = tk.BooleanVar()
  1670. self.cyto_var.set(False)
  1671. SO.cyto_var = self.cyto_var.get()
  1673. self.nuc_var = tk.BooleanVar()
  1674. self.nuc_var.set(True)
  1675. SO.nuc_var = self.nuc_var.get()
  1677. self.segment_2D = tk.BooleanVar()
  1678. self.segment_2D.set(True)
  1679. SO.segment_2D = self.segment_2D.get()
  1681. self.segment_3D = tk.BooleanVar()
  1682. self.segment_3D.set(False)
  1683. SO.segment_3D = self.segment_3D.get()
  1685. self.same_for_all_images_var = tk.BooleanVar()
  1686. self.same_for_all_images_var.set(False)
  1687. SO.same_for_all_images_var = self.same_for_all_images_var.get()
  1689. tk.Label(self.root, text="Mask channel:").place(relx=0.01, rely=0.05)
  1690. ttk.Combobox(self.root, values=list(range(self.image.num_channels)), textvariable=self.mask_channel_var, width=int(0.005 * window_size[0])).place(relx=0.1, rely=0.05)
  1692. self.cyto_checkbox = tk.Checkbutton(self.root, text="cyto", variable=self.cyto_var, command=self.toggle_nuc)
  1693. self.cyto_checkbox.place(relx=0.01, rely=0.1)
  1695. self.nuc_checkbox = tk.Checkbutton(self.root, text="nuc", variable=self.nuc_var, command=self.toggle_cyto)
  1696. self.nuc_checkbox.place(relx=0.1, rely=0.1)
  1698. tk.Label(self.root, text="Channels of interest:").place(relx=0.01, rely=0.15)
  1700. self.channel_vars = []
  1701. col = 0.1
  1702. for i in range(self.image.num_channels):
  1703. channel_var = tk.BooleanVar()
  1704. channel_var.set(True)
  1705. self.channel_vars.append(channel_var)
  1707. tk.Label(self.root, text=f"{i+1}:").place(relx=col, rely=0.15)
  1708. col += 0.015
  1709. tk.Checkbutton(self.root, text="", variable=channel_var).place(relx=col, rely=0.15)
  1710. col += 0.015
  1712. SO.channel_vars = self.channel_vars
  1714. tk.Checkbutton(self.root, text="2D", variable=self.segment_2D).place(relx=0.01, rely=0.20)
  1716. tk.Checkbutton(self.root, text="3D", variable=self.segment_3D).place(relx=0.07, rely=0.20)
  1718. # tk.Checkbutton(self.root, text="Same for all images?", variable=self.same_for_all_images_var).place(relx=0.01, rely=0.40)
  1720. tk.Button(self.root, text="Segment and Process", command=self.segment_and_process).place(relx=0.01, rely=0.30, relwidth=0.2, relheight=0.1)
  1722. tk.Label(self.root, text="Channels: (top-to-bottom, left-to-right) 0 -> n").place(relx=0.33, rely=0.01)
  1723. mip_panel = ImageTk.PhotoImage(Image.fromarray(cv2.resize(np.array(self.image.mip_panel).astype('uint8'), (int(0.35 * window_size[0]), int(0.9 * window_size[1])))))
  1724. self.mip_panel_label = tk.Label(self.root, image=mip_panel)
  1725. self.mip_panel_label.place(relx=0.25, rely=0.05)
  1727. tk.Label(self.root, text="Mask channel").place(relx=0.78, rely=0.01)
  1728. mip = ImageTk.PhotoImage(Image.fromarray(cv2.resize(self.image.mip[0, :, :].astype('uint8'), (int(0.35 * window_size[0]), int(0.9 * window_size[1])))))
  1729. self.mask_label = tk.Label(self.root, image=mip)
  1730. self.mask_label.place(relx=0.64, rely=0.05)
  1732. self.mask_channel_var.trace('w', self.mask_channel_changed)
  1734. self.root.mainloop()
  1736. def wait_and_get_values(self):
  1737. self.root.wait_window()
  1738. return {
  1739. 'mask_channel': self.mask_channel_var.get(),
  1740. 'cyto': self.cyto_var.get(),
  1741. 'nuc': self.nuc_var.get(),
  1742. 'channels_of_interest': [var.get() for var in self.channels_of_interest_vars],
  1743. 'same_for_all_images': self.same_for_all_images_var.get()
  1744. }
  1746. def toggle_cyto(self):
  1747. if self.nuc_var.get():
  1748. self.cyto_var.set(False)
  1749. else:
  1750. self.cyto_var.set(True)
  1752. SO.cyto_var = self.cyto_var.get()
  1754. def toggle_nuc(self):
  1755. if self.cyto_var.get():
  1756. self.nuc_var.set(False)
  1757. else:
  1758. self.nuc_var.set(True)
  1760. SO.nuc_var = self.nuc_var.get()
  1762. def mask_channel_changed(self, *args):
  1763. mask_channel = self.mask_channel_var.get()
  1764. mask = self.image.mip[mask_channel, :, :]
  1765. mask_resized = cv2.resize(mask, (500, 500))
  1766. self.mask_image = ImageTk.PhotoImage(Image.fromarray(mask_resized))
  1767. self.mask_label.config(image=self.mask_image)
  1768. self.mask_label.image = self.mask_image
  1770. SO.mask_channel = mask_channel
  1772. def segment_and_process(self):
  1773. self.channels_of_interest_vars = [var for var in self.channel_vars if var.get()]
  1774. SO.channels_of_interest_vars = self.channels_of_interest_vars
  1775. self.root.destroy()
  1777. def reduction(obj, ufunc, method, axis, dtype, out):
  1778. return ufunc.reduce(obj, axis, dtype, out)
  1780. def xml_to_dict(xml_str):
  1781. def recursive_dictify(element):
  1782. children = list(element)
  1783. if not children:
  1784. return element.text
  1785. return {child.tag: recursive_dictify(child) for child in children}
  1787. root = ET.fromstring(xml_str)
  1788. return recursive_dictify(root)
  1790. def ends_with_ch0X_tif(filename):
  1791. # The regular expression pattern to match the filename
  1792. pattern = r'_ch0[0-9]\.tif$'
  1794. # Use the search function to check if the pattern matches the end of the filename
  1795. match = re.search(pattern, filename)
  1797. # If match is not None, that means the pattern was found in the filename
  1798. return match is not None
  1800. def find_all_images_in_path(search_path, filetype=''):
  1801. """
  1802. search a given directory for all images czi, lif, tif
  1803. """
  1804. os.chdir(search_path)
  1805. image_files = []
  1806. for root, _, files in os.walk('.'):
  1807. for file in files:
  1808. if file[0] == '.':
  1809. continue # since mac folder info
  1810. if file.endswith(filetype):
  1811. if ends_with_ch0X_tif(file):
  1812. continue
  1813. image_files.append(os.path.join(root, file))
  1815. if not image_files:
  1816. raise ValueError('no images found in search path')
  1817. return
  1819. return image_files
  1822. def process_mosaic(m, mosaic, cellpose_model, diam, flow_threshold, cellprob_threshold, channels):
  1824. print(f'Processing mosaic {m}')
  1825. cellpose_out = cellpose_model.eval(
  1826. np.max(mosaic[:, :, :, :, m], axis=1).astype('uint8'),
  1827. diameter=diam,
  1828. flow_threshold=flow_threshold,
  1829. cellprob_threshold=cellprob_threshold,
  1830. channels=channels,
  1831. tile=True
  1832. )
  1834. # Return the necessary data for further processing
  1835. return m, cellpose_out[0], cellpose_out[1][0]
  1837. def process_file(po):
  1838. """
  1839. processes a file
  1840. """
  1842. global SO,\
  1843. model_choice,\
  1844. diam, \
  1845. flow_threshold, \
  1846. cellprob_threshold, \
  1847. alter_mask_channel, \
  1848. mask_ch, \
  1849. image
  1851. print('\033[93m', end='')
  1852. print(f'\nprocessing path: {po.image_path}\n'
  1853. f'with save path: {po.save_path}; '
  1854. f'and save options: \n'
  1855. f'channels: {po.save_mip_channels}'
  1856. f', panel: {po.save_mip_panel}'
  1857. f', merge: {po.save_mip_merge}'
  1858. f', dye overlay: {po.save_dye_overlaid}'
  1859. f', colors: {po.save_colors}')
  1860. print('\033[0m', end='')
  1862. image = BioImage() # initiate
  1864. image.path = po.image_path
  1866. if po.image_path.endswith('.czi'):
  1867. if image.load_czi() == 'metadata_only':
  1868. print(f'Image contained metadata only, skipping: {po.image_path}')
  1869. return
  1870. elif po.image_path.endswith('.lif'):
  1871. image.load_lif()
  1872. elif po.image_path.endswith('.tif'):
  1873. image.load_tif()
  1875. if np.all(image.im == 0) and not image.big_image:
  1876. print(f"image empty: {image.path}, skipping")
  1877. return
  1879. #if image.im == [0, 0] and not image.big_image:
  1880. # print(f"image empty: {image.path}, skipping")
  1881. # return
  1883. # loading and saving the image
  1884. image.extract_colors()
  1886. image.project_mip(side_projections=True, z_scale=3)
  1888. image.normalize(gamma=1)
  1890. image.save(po.save_path,
  1891. po.save_mip_channels,
  1892. po.save_mip_panel,
  1893. po.save_mip_merge,
  1894. po.save_dye_overlaid,
  1895. po.save_colors)
  1897. if not po.segment_image:
  1898. return
  1900. # check if variable 'so' exists
  1901. if 'SO' not in globals():
  1902. # create segmentation GUI
  1903. SegmentationGUI(tk.Tk(), image)
  1905. # if this is still empty but you're segmenting, then assume you want every channel
  1906. if not SO.channels_of_interest_vars:
  1907. SO.channels_of_interest_vars = [True] * image.num_channels
  1909. # if 'model_choice' is not defined or is None, then set its value based on SO.nuc_var
  1910. using_pretrained_model = False
  1911. if not globals().get('model_choice'):
  1912. if SO.nuc_var:
  1913. model_choice = "nuclei" # @param ["cyto", "nuclei", "cyto2", "tissuenet", "livecell"]
  1914. else:
  1915. model_choice = "cyto"
  1916. else:
  1917. using_pretrained_model = True
  1919. image.mask_ch = SO.mask_channel_var
  1920. if using_pretrained_model:
  1921. cellpose_model = models.CellposeModel(gpu=True, pretrained_model=model_choice)
  1922. else:
  1923. cellpose_model = models.Cellpose(gpu=True, model_type=model_choice)
  1925. cellpose_model.device = DEVICE
  1927. if globals().get('alter_mask_channel'):
  1928. if len(mask_ch) == 1:
  1929. channels = [image.mask_ch, image.mask_ch]
  1930. elif len(mask_ch) == 2:
  1931. channels = mask_ch
  1933. image.mask_ch = mask_ch[0]
  1935. else:
  1936. # image.mask_ch was fine before you started messing with this.
  1937. channels = [[image.mask_ch, image.mask_ch]]
  1939. if not ('diam' in globals()):
  1940. diam = None # for autofit
  1942. # diam = 7 * image.scale[1] # ~7 µm diameter for hiPSCs
  1943. if not ('flow_threshold' in globals()):
  1944. flow_threshold = 0.3 # @{type:"slider", min:0.1, max:1.1, step:0.1}
  1946. if not ('cellprob_threshold' in globals()):
  1947. cellprob_threshold = -1.5 # @{type:"slider", min:-6, max:6, step:1}
  1949. if not ('stitch_threshold' in globals()):
  1950. stitch_threshold = 0.0 # @{type:"slider", min:-6, max:6, step:1}
  1952. if SO.segment_2D or image.im.shape[1] == 1:
  1954. if not image.big_image:
  1956. print('segmenting 2D image / mip ...')
  1958. # reorganize to a rgb
  1959. cellpose_image = np.zeros((3, image.mip.shape[2], image.mip.shape[1]))
  1961. ''' number on the RHS is the channel number from the image name (i.e. X in _ch0X.tif) '''
  1962. cellpose_image[0, :, :] = image.mip[2, :, :] # R
  1963. cellpose_image[1, :, :] = image.mip[1, :, :] # G
  1964. cellpose_image[2, :, :] = image.mip[0, :, :] # B
  1966. # note that image.mask_ch is not transformed with the cellpose bindings
  1968. # cellpose_image = cellpose_image.transpose(2, 1, 0).astype('uint8')
  1969. # plt.imshow(cellpose_image)
  1970. # print(f'diam:{diam}, ft:{flow_threshold}, cpt:{cellprob_threshold}, ch:{channels}')
  1971. # plt.savefig('out.png')
  1973. cellpose_out = cellpose_model.eval(cellpose_image.astype('uint8'),
  1974. diameter=diam,
  1975. flow_threshold=flow_threshold,
  1976. cellprob_threshold=cellprob_threshold,
  1977. channels=channels)
  1979. image.mask = cellpose_out[0]
  1980. image.flow = cellpose_out[1]
  1981. try:
  1982. image.diam = cellpose_out[3]
  1983. except:
  1984. print('no diameter returned')
  1985. image.diam = -1
  1987. if image.big_image:
  1989. image.mask = np.zeros((image.mosaic.shape[2], image.mosaic.shape[3], image.num_mosaics))
  1990. image.flow = np.zeros((image.mosaic.shape[2], image.mosaic.shape[3], 3, image.num_mosaics))
  1991. image.masks_combined = np.zeros(
  1992. (image.bbox[:, 1].max() + image.bbox[:, 3].max(),
  1993. image.bbox[:, 0].max() + image.bbox[:, 2].max(),
  1994. 4), dtype=image.mask.dtype)
  1996. """number on the RHS is the channel number from the image name
  1997. (i.e. X in _ch0X.tif), in order RGB"""
  1999. image.mosaic = image.mosaic[[2, 1, 0], :, :, :, :]
  2001. # # parallel -> untested, something like this might work
  2002. # # Create a partial function with the fixed parameters
  2003. # partial_process_mosaic = partial(
  2004. # process_mosaic,
  2005. # mosaic=image.mosaic,
  2006. # cellpose_model=cellpose_model,
  2007. # diam=diam,
  2008. # flow_threshold=flow_threshold,
  2009. # cellprob_threshold=cellprob_threshold,
  2010. # channels=channels
  2011. # )
  2012. #
  2013. # # Use the partial function with the multiprocessing Pool
  2014. # print('Initializing a parallel process...')
  2015. # pool = Pool(processes=cpu_count())
  2016. # results = list(tqdm(pool.imap(partial_process_mosaic, range(image.num_mosaics)), desc="Segmenting a big mosaic"))
  2017. #
  2018. # # multiprocessing for big images is necessary
  2019. # for result in tqdm(results, desc="Processing results"):
  2020. # m, mask, flow = result
  2021. #
  2022. # # Determine the # rows and columns in the mosaic (assumes square im)
  2023. # row = image.bbox[m, 0] // image.bbox[1, 0]
  2024. # col = image.bbox[m, 1] // image.bbox[1, 0]
  2025. #
  2026. # image.mask[:, :, m] = mask
  2027. # image.flow[:, :, :, m] = flow
  2028. #
  2029. # # Add the mask to the appropriate z-stack
  2030. # image.masks_combined[image.bbox[m, 1]:image.bbox[m, 1] + image.bbox[m, 3],
  2031. # image.bbox[m, 0]:image.bbox[m, 0] + image.bbox[m, 2],
  2032. # (row % 2) * 2 + (col % 2)
  2033. # ] = image.mask[:, :, m]
  2035. # serial
  2036. max_in_masks = 0
  2038. for m in tqdm(range(image.num_mosaics), desc="Segmenting a big mosaic"):
  2040. row = image.bbox[m, 0] // image.bbox[1, 0]
  2041. col = image.bbox[m, 1] // image.bbox[1, 0]
  2043. # # here for debugging / testing. check to see if the image is being segmented correctly
  2044. # if row > 2 or col > 2:
  2045. # continue
  2047. cellpose_image = np.max(image.mosaic[:, :, :, :, m], axis=1)
  2049. cellpose_out = cellpose_model.eval(
  2050. cellpose_image.astype('uint8'),
  2051. diameter=diam,
  2052. flow_threshold=flow_threshold,
  2053. cellprob_threshold=cellprob_threshold,
  2054. channels=channels,
  2055. tile=True)
  2057. image.mask[:, :, m] = cellpose_out[0] + max_in_masks * (cellpose_out[0] > 0)
  2058. image.flow[:, :, :, m] = cellpose_out[1][0]
  2060. # Add the mask to the appropriate z-stack
  2061. image.masks_combined[image.bbox[m, 1]:image.bbox[m, 1] + image.bbox[m, 3],
  2062. image.bbox[m, 0]:image.bbox[m, 0] + image.bbox[m, 2],
  2063. (row % 2) * 2 + (col % 2)] = image.mask[:, :, m]
  2065. # max of all in image
  2066. max_in_masks = image.masks_combined.max()
  2068. # combine masks handling overlap
  2069. image.mask = image.combine_big_image_masks(image.masks_combined).astype('uint16')
  2071. # process
  2072. image.process_2d_mask()
  2074. # plot
  2075. #image.plot_2d_mask()
  2076. #This function doesn't seem to be doing anything because plotshow is commmented out
  2078. # save into a comma separated value file
  2079. image.save_2d_mask(po)
  2081. if SO.segment_3D and image.im.shape[1] > 1:
  2082. print('no implementation for 3D as yet')
  2084. return image.mask_props
  2086. def scripting():
  2088. global model_choice, diam, flow_threshold, cellprob_threshold, alter_mask_channel, mask_ch
  2090. po = ProcessOptions()
  2092. files = find_all_images_in_path(r"C:\Users\Ben\Downloads\A81 16 Weeks BMSRAD70 Ki67 BL54_D111 scRNA\ki67", '.tif')
  2093. model_choice = r"C:\Users\Ben\Documents\RA PAPER IHC CELLPOSE\cellseg\Cellpose Models\CP_nrl_crx"
  2095. diam = 12 # autofit, or change for purpose
  2096. flow_threshold = 0.9 # defaults ~ 0.1 to 3.0 (fewer to more cells), comment if not needed 0.9
  2097. cellprob_threshold = 0.0001 # defaults ~ -6 to 6 (more to fewer pixels), comment if not need 0.0001
  2098. alter_mask_channel = True
  2100. #""" I think the inputs here 0-3 are: 0 for gray, 1 for red, 2 for green, 3 for blue """
  2101. mask_ch = [2,3]# this might accept two channels like this in a list, but a len(1) int should work as well
  2102. # ch00 = blue = 3
  2103. # ch01 = green = 2
  2104. # ch02 = red = 1
  2106. mask_properties = [None] * len(files)
  2108. for n, file in enumerate(files):
  2110. po.image_path = file
  2111. po.save_path = os.path.dirname(file)
  2113. po.save_mip_channels = False
  2114. po.save_mip_panel = False
  2115. po.save_mip_merge = False
  2116. po.save_dye_overlaid = False
  2117. po.save_colors = False
  2119. global SO
  2120. SO = SegmentationOptions()
  2121. po.segment_image = True
  2123. mask_properties[n] = process_file(po)
  2125. # save a csv file with the name of all files, and the total number of mask objects in each image
  2126. print('saving master cell count')
  2127. with open(os.path.join(po.save_path, 'image_count.csv'), 'w') as f:
  2128. writer = csv.writer(f)
  2129. writer.writerow(['file', 'num_mask_objects'])
  2130. files_and_masks = zip(files, mask_properties)
  2131. for file, mask in files_and_masks:
  2132. writer.writerow([file, len(mask.area)])
  2135. if __name__ == '__main__':
  2137. # gui = MainGUI()
  2139. scripting()
  2141. # check that GUI still works with the introduction of the new class SO.
  2143. # check out line ~1140 to change the segmentation model for cell pose
  2145. # TBD
  2146. # (1) add 3D segmentation characterisations,
  2147. # (2) add stardist,
  2149. print('Ok.')

main.py at commit 59a4cac, under CC0-1.0 · at the source

Overview

Authors: Benjamin Y. Lim1,2, Carissa Chen2,3, Anna Fredericks2,3, Elham Nilli1, Santiago Mesa Mora1, Megan Weatherstone4, To Ha Loi5, Peter Newman6, Nader Aryamanesh7, Hala Zreiqat6, Patrick Tam2,8, Pengyi Yang3,9, Anai Gonzalez-Cordero1,2
ORCID iDs: Benjamin Y. Lim, Carissa Chen, Anna Fredericks, Peter Newman, Nader Aryamanesh, Hala Zreiqat, Patrick Tam, Pengyi Yang, Anai Gonzalez-Cordero
  1. Stem Cell Medicine Unit, Children’s Medical Research Institute,Westmead, NSW Australia
  2. School of Medical Sciences, Faculty of Medicine and Health, The University of Sydney,Camperdown, NSW Australia
  3. Computational Systems Biology Unit, Children’s Medical Research Institute,Westmead, NSW Australia
  4. Single Cell Analytics Facility, Children’s Medical Research Institute,Westmead, NSW Australia
  5. Eye Genetics Research Unit, Children’s Medical Research Institute,Westmead, NSW Australia
  6. School of Biomedical Engineering, Faculty of Engineering, University of Sydney,Camperdown, NSW Australia
  7. Bioinformatics Facility, Children’s Medical Research Institute,Westmead, NSW Australia
  8. Embryology Unit, Children’s Medical Research Institute,Westmead, NSW Australia
  9. School of Mathematics and Statistics, The University of Sydney,Camperdown, NSW Australia
Institutions: Children's Medical Research Institute (Australia); The University of Sydney (Australia)
Journal: Nature communications, volume 17, issue 1, article 5702
Dates: received 8 October 2025; accepted 8 April 2026; published online 25 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-72130-3 · PMID 42031716 · PMCID PMC13319458 · OpenAlex W7155499606
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity
Keywords: Differentiation, Cellular signalling networks, Stem-cell differentiation
MeSH: Cell Differentiation*, Organoids*, Retina*, Tretinoin*, Gene Expression Regulation, Developmental, Humans, Signal Transduction (* major topic)
Topic: Retinal Development and Disorders (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Health and Medical Research Council (1173469)
Citations: cited by 2 papers (Europe PMC); 101 references in the paper

Abstract

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

Repositories

Its files are read in the Code ↔ Paper reader above.

Stem-Cell-Medicine-Lab/Cellpose_pipeline-models

License: CC0-1.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 59a4cac17caef1533be9d96ba91c626f00694d88, 4 April 2025
Languages: Python (1)
Size: 9 files, 1 script
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: Cellpose (1 file), Matplotlib (1 file), NumPy (1 file), OpenCV (1 file), Pillow (1 file), PyTorch (1 file), scikit-image (1 file), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
3 files
At the source: github.com/Stem-Cell-Medicine-Lab/Cellpose_pipeline-models

Zenodo 19324349

License: CC0-1.0
State: the link answers, verified on 30 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 30 September 2026: the link answers (HTTP 200)
  • 30 September 2026: the link answers (HTTP 200)
At the source:

blim934/cellpose_pipeline-models

License: CC0-1.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 59a4cac17caef1533be9d96ba91c626f00694d88, 4 April 2025
Languages: Python (1)
Size: 9 files, 1 script
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: Cellpose (1 file), Matplotlib (1 file), NumPy (1 file), OpenCV (1 file), Pillow (1 file), PyTorch (1 file), scikit-image (1 file), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
3 files
At the source: github.com/blim934/Cellpose_pipeline-models/tree/Cellpose

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/s41467-026-72130-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:

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

Code and data availability statement

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

Read it in the paper: doi.org/10.1038/s41467-026-72130-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 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 13 authors, 3 keywords, 7 MeSH terms, 1 funder, 98 references.

Cite

This paper

Lim, B. Y., Chen, C., Fredericks, A., Nilli, E., Mesa Mora, S., Weatherstone, M., Loi, T. H., Newman, P., Aryamanesh, N., Zreiqat, H., Tam, P., Yang, P., & Gonzalez-Cordero, A. (2026). Retinoic acid drives cell fate specification, maturation and retinal regionality in human retinal organoids. Nature communications, 17(1), 5702. https://doi.org/10.1038/s41467-026-72130-3

BibTeX

@article{lim2026retinoic,
author = {Lim, Benjamin Y. and Chen, Carissa and Fredericks, Anna and Nilli, Elham and Mesa Mora, Santiago and Weatherstone, Megan and Loi, To Ha and Newman, Peter and Aryamanesh, Nader and Zreiqat, Hala and Tam, Patrick and Yang, Pengyi and Gonzalez-Cordero, Anai},
title = {{Retinoic acid drives cell fate specification, maturation and retinal regionality in human retinal organoids}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {5702},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-72130-3},
url = {https://doi.org/10.1038/s41467-026-72130-3},
pmid = {42031716},
pmcid = {PMC13319458}
}

RIS

TY - JOUR
AU - Lim, Benjamin Y.
AU - Chen, Carissa
AU - Fredericks, Anna
AU - Nilli, Elham
AU - Mesa Mora, Santiago
AU - Weatherstone, Megan
AU - Loi, To Ha
AU - Newman, Peter
AU - Aryamanesh, Nader
AU - Zreiqat, Hala
AU - Tam, Patrick
AU - Yang, Pengyi
AU - Gonzalez-Cordero, Anai
TI - Retinoic acid drives cell fate specification, maturation and retinal regionality in human retinal organoids
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/25
VL - 17
IS - 1
SP - 5702
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-72130-3
UR - https://doi.org/10.1038/s41467-026-72130-3
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-72130-3",
"type": "article-journal",
"title": "Retinoic acid drives cell fate specification, maturation and retinal regionality in human retinal organoids",
"container-title": "Nature communications",
"author": [
{
"family": "Lim",
"given": "Benjamin Y."
},
{
"family": "Chen",
"given": "Carissa"
},
{
"family": "Fredericks",
"given": "Anna"
},
{
"family": "Nilli",
"given": "Elham"
},
{
"family": "Mesa Mora",
"given": "Santiago"
},
{
"family": "Weatherstone",
"given": "Megan"
},
{
"family": "Loi",
"given": "To Ha"
},
{
"family": "Newman",
"given": "Peter"
},
{
"family": "Aryamanesh",
"given": "Nader"
},
{
"family": "Zreiqat",
"given": "Hala"
},
{
"family": "Tam",
"given": "Patrick"
},
{
"family": "Yang",
"given": "Pengyi"
},
{
"family": "Gonzalez-Cordero",
"given": "Anai"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5702",
"DOI": "10.1038/s41467-026-72130-3",
"PMID": "42031716",
"PMCID": "PMC13319458",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-72130-3",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
25
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41467-026-76112-3
Photostimulation improves maturation of human photoreceptors.
Journal: Nature communications
In common: 9 references
[2] doi:10.1016/j.celrep.2026.117270 [code]
Blocking apoptosis promotes survival and alters developmental dynamics of human retinal ganglion cells in retinal organoids.
Journal: Cell reports
In common: SciPy, Matplotlib, NumPy, 7 references
[3] doi:10.64898/2026.03.30.714220 [code]
An integrated single cell and spatial omics atlas of human prenatal development
Journal: bioRxiv (preprint)
In common: Pillow, PyTorch, SciPy, 2 other tools, 5 references
[4] 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: Cellpose, OpenCV, scikit-image, 5 other tools, 2 references
[5] doi:10.1038/s44320-026-00208-7 [code]
Interpretable deep generative ensemble learning for single-cell omics with Hydra.
Journal: Molecular systems biology
In common: PyTorch, SciPy, Matplotlib, 1 other tool, 2 references, author Pengyi Yang
[6] doi:10.1038/s41467-026-71458-0 [code]
Early differential impact of MeCP2 mutations on functional networks in Rett syndrome patient-derived human cortical organoids.
Journal: Nature communications
In common: Cellpose, OpenCV, scikit-image, 4 other tools, 2 references
[7] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: PyTorch, SciPy, Matplotlib, 1 other tool, 5 references
[8] doi:10.1186/s13287-026-05027-z
Functional development of photoreceptors in human retinal organoids.
Journal: Stem cell research & therapy
In common: 6 references
[9] doi:10.1016/j.isci.2026.116355 [code]
Tera-MIND: Tera-scale mouse brain simulation via spatial mRNA-guided diffusion.
Journal: iScience
In common: Cellpose, OpenCV, Pillow, 4 other tools, 1 reference
[10] doi:10.1038/s41467-026-74320-5 [code]
Spatial architecture of autism pathogenesis reveals mosaic structural disarray during early development.
Journal: Nature communications
In common: OpenCV, scikit-image, Pillow, 3 other tools, 3 references

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.