OSCR

Nuclear Enlargement as a Histological Hallmark of Skeletal Muscle Aging, Revealed by Deep Learning-Driven Analysis and Validated in Inflammatory Myopathies.

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 · 627 lines · 22 KB · BSD-3-Clause

  1. #!/usr/bin/env python3
  3. #
  4. # Deep Zoom Tools
  5. #
  6. # Copyright (c) 2008-2019, Daniel Gasienica <[email hidden]>
  7. # Copyright (c) 2008-2011, OpenZoom <http://openzoom.org>
  8. # Copyright (c) 2010, Boris Bluntschli <[email hidden]>
  9. # Copyright (c) 2008, Kapil Thangavelu <[email hidden]>
  10. # All rights reserved.
  11. #
  12. # Redistribution and use in source and binary forms, with or without modification,
  13. # are permitted provided that the following conditions are met:
  14. #
  15. # 1. Redistributions of source code must retain the above copyright notice,
  16. # this list of conditions and the following disclaimer.
  17. #
  18. # 2. Redistributions in binary form must reproduce the above copyright
  19. # notice, this list of conditions and the following disclaimer in the
  20. # documentation and/or other materials provided with the distribution.
  21. #
  22. # 3. Neither the name of OpenZoom nor the names of its contributors may be used
  23. # to endorse or promote products derived from this software without
  24. # specific prior written permission.
  25. #
  26. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  27. # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  28. # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  29. # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  30. # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  31. # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32. # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  33. # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34. # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35. # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36. #
  38. import io
  39. import math
  40. import optparse
  41. import os
  42. import shutil
  43. from urllib.parse import urlparse
  44. import sys
  45. import time
  46. import urllib.request
  47. import warnings
  48. import xml.dom.minidom
  50. import PIL.Image
  52. from collections import deque
  55. NS_DEEPZOOM = "http://schemas.microsoft.com/deepzoom/2008"
  57. DEFAULT_RESIZE_FILTER = PIL.Image.LANCZOS
  58. DEFAULT_IMAGE_FORMAT = "jpg"
  60. RESIZE_FILTERS = {
  61. "bilinear": PIL.Image.BILINEAR,
  62. "bicubic": PIL.Image.BICUBIC,
  63. "nearest": PIL.Image.NEAREST,
  64. "lanczos": PIL.Image.LANCZOS,
  65. }
  67. IMAGE_FORMATS = {
  68. "jpg": "jpg",
  69. "png": "png",
  70. }
  73. class DeepZoomImageDescriptor(object):
  74. def __init__(
  75. self, width=None, height=None, tile_size=254, tile_overlap=1, tile_format="jpg"
  76. ):
  77. self.width = width
  78. self.height = height
  79. self.tile_size = tile_size
  80. self.tile_overlap = tile_overlap
  81. self.tile_format = tile_format
  82. self._num_levels = None
  84. def open(self, source):
  85. """Intialize descriptor from an existing descriptor file."""
  86. doc = xml.dom.minidom.parse(safe_open(source))
  87. image = doc.getElementsByTagName("Image")[0]
  88. size = doc.getElementsByTagName("Size")[0]
  89. self.width = int(size.getAttribute("Width"))
  90. self.height = int(size.getAttribute("Height"))
  91. self.tile_size = int(image.getAttribute("TileSize"))
  92. self.tile_overlap = int(image.getAttribute("Overlap"))
  93. self.tile_format = image.getAttribute("Format")
  95. def save(self, destination):
  96. """Save descriptor file."""
  97. file = open(destination, "wb")
  98. doc = xml.dom.minidom.Document()
  99. image = doc.createElementNS(NS_DEEPZOOM, "Image")
  100. image.setAttribute("xmlns", NS_DEEPZOOM)
  101. image.setAttribute("TileSize", str(self.tile_size))
  102. image.setAttribute("Overlap", str(self.tile_overlap))
  103. image.setAttribute("Format", str(self.tile_format))
  104. size = doc.createElementNS(NS_DEEPZOOM, "Size")
  105. size.setAttribute("Width", str(self.width))
  106. size.setAttribute("Height", str(self.height))
  107. image.appendChild(size)
  108. doc.appendChild(image)
  109. descriptor = doc.toxml(encoding="UTF-8")
  110. file.write(descriptor)
  111. file.close()
  113. @classmethod
  114. def remove(self, filename):
  115. """Remove descriptor file (DZI) and tiles folder."""
  116. _remove(filename)
  118. @property
  119. def num_levels(self):
  120. """Number of levels in the pyramid."""
  121. if self._num_levels is None:
  122. max_dimension = max(self.width, self.height)
  123. self._num_levels = int(math.ceil(math.log(max_dimension, 2))) + 1
  124. return self._num_levels
  126. def get_scale(self, level):
  127. """Scale of a pyramid level."""
  128. assert 0 <= level and level < self.num_levels, "Invalid pyramid level"
  129. max_level = self.num_levels - 1
  130. return math.pow(0.5, max_level - level)
  132. def get_dimensions(self, level):
  133. """Dimensions of level (width, height)"""
  134. assert 0 <= level and level < self.num_levels, "Invalid pyramid level"
  135. scale = self.get_scale(level)
  136. width = int(math.ceil(self.width * scale))
  137. height = int(math.ceil(self.height * scale))
  138. return (width, height)
  140. def get_num_tiles(self, level):
  141. """Number of tiles (columns, rows)"""
  142. assert 0 <= level and level < self.num_levels, "Invalid pyramid level"
  143. w, h = self.get_dimensions(level)
  144. return (
  145. int(math.ceil(float(w) / self.tile_size)),
  146. int(math.ceil(float(h) / self.tile_size)),
  147. )
  149. def get_tile_bounds(self, level, column, row):
  150. """Bounding box of the tile (x1, y1, x2, y2)"""
  151. assert 0 <= level and level < self.num_levels, "Invalid pyramid level"
  152. offset_x = 0 if column == 0 else self.tile_overlap
  153. offset_y = 0 if row == 0 else self.tile_overlap
  154. x = (column * self.tile_size) - offset_x
  155. y = (row * self.tile_size) - offset_y
  156. level_width, level_height = self.get_dimensions(level)
  157. w = self.tile_size + (1 if column == 0 else 2) * self.tile_overlap
  158. h = self.tile_size + (1 if row == 0 else 2) * self.tile_overlap
  159. w = min(w, level_width - x)
  160. h = min(h, level_height - y)
  161. return (x, y, x + w, y + h)
  164. class DeepZoomCollection(object):
  165. def __init__(
  166. self,
  167. filename,
  168. image_quality=0.8,
  169. max_level=7,
  170. tile_size=256,
  171. tile_format="jpg",
  172. tile_background_color="#000000",
  173. items=[],
  174. ):
  175. self.source = filename
  176. self.image_quality = image_quality
  177. self.tile_size = tile_size
  178. self.max_level = max_level
  179. self.tile_format = tile_format
  180. self.tile_background_color = tile_background_color
  181. self.items = deque(items)
  182. self.next_item_id = len(self.items)
  183. # XML
  184. self.doc = xml.dom.minidom.Document()
  185. collection = self.doc.createElementNS(NS_DEEPZOOM, "Collection")
  186. collection.setAttribute("xmlns", NS_DEEPZOOM)
  187. collection.setAttribute("MaxLevel", str(self.max_level))
  188. collection.setAttribute("TileSize", str(self.tile_size))
  189. collection.setAttribute("Format", str(self.tile_format))
  190. collection.setAttribute("Quality", str(self.image_quality))
  191. # TODO: Append items passed in as argument
  192. items = self.doc.createElementNS(NS_DEEPZOOM, "Items")
  193. collection.appendChild(items)
  194. collection.setAttribute("NextItemId", str(self.next_item_id))
  195. self.doc.appendChild(collection)
  197. @classmethod
  198. def from_file(self, filename):
  199. """Open collection descriptor."""
  200. doc = xml.dom.minidom.parse(safe_open(filename))
  201. collection = doc.getElementsByTagName("Collection")[0]
  202. image_quality = float(collection.getAttribute("Quality"))
  203. max_level = int(collection.getAttribute("MaxLevel"))
  204. tile_size = int(collection.getAttribute("TileSize"))
  205. tile_format = collection.getAttribute("Format")
  206. items = [
  207. DeepZoomCollectionItem.from_xml(item)
  208. for item in doc.getElementsByTagName("I")
  209. ]
  211. collection = DeepZoomCollection(
  212. filename,
  213. image_quality=image_quality,
  214. max_level=max_level,
  215. tile_size=tile_size,
  216. tile_format=tile_format,
  217. items=items,
  218. )
  219. return collection
  221. @classmethod
  222. def remove(self, filename):
  223. """Remove collection file (DZC) and tiles folder."""
  224. _remove(filename)
  226. def append(self, source):
  227. descriptor = DeepZoomImageDescriptor()
  228. descriptor.open(source)
  229. item = DeepZoomCollectionItem(
  230. source, descriptor.width, descriptor.height, id=self.next_item_id
  231. )
  232. self.items.append(item)
  233. self.next_item_id += 1
  235. def save(self, pretty_print_xml=False):
  236. """Save collection descriptor."""
  237. collection = self.doc.getElementsByTagName("Collection")[0]
  238. items = self.doc.getElementsByTagName("Items")[0]
  239. while len(self.items) > 0:
  240. item = self.items.popleft()
  241. i = self.doc.createElementNS(NS_DEEPZOOM, "I")
  242. i.setAttribute("Id", str(item.id))
  243. i.setAttribute("N", str(item.id))
  244. i.setAttribute("Source", item.source)
  245. # Size
  246. size = self.doc.createElementNS(NS_DEEPZOOM, "Size")
  247. size.setAttribute("Width", str(item.width))
  248. size.setAttribute("Height", str(item.height))
  249. i.appendChild(size)
  250. items.appendChild(i)
  251. self._append_image(item.source, item.id)
  252. collection.setAttribute("NextItemId", str(self.next_item_id))
  253. with open(self.source, "wb") as f:
  254. if pretty_print_xml:
  255. xml = self.doc.toprettyxml(encoding="UTF-8")
  256. else:
  257. xml = self.doc.toxml(encoding="UTF-8")
  258. f.write(xml)
  260. def _append_image(self, path, i):
  261. descriptor = DeepZoomImageDescriptor()
  262. descriptor.open(path)
  263. files_path = _get_or_create_path(_get_files_path(self.source))
  264. for level in reversed(range(self.max_level + 1)):
  265. level_path = _get_or_create_path("%s/%s" % (files_path, level))
  266. level_size = 2 ** level
  267. images_per_tile = int(math.floor(self.tile_size / level_size))
  268. column, row = self.get_tile_position(i, level, self.tile_size)
  269. tile_path = "%s/%s_%s.%s" % (level_path, column, row, self.tile_format)
  270. if not os.path.exists(tile_path):
  271. tile_image = PIL.Image.new(
  272. "RGB", (self.tile_size, self.tile_size), self.tile_background_color
  273. )
  274. if self.tile_format == "jpg":
  275. jpeg_quality = int(self.image_quality * 100)
  276. tile_image.save(tile_path, "JPEG", quality=jpeg_quality)
  277. else:
  278. tile_image.save(tile_path)
  279. tile_image = PIL.Image.open(tile_path)
  280. source_path = "%s/%s/%s_%s.%s" % (
  281. _get_files_path(path),
  282. level,
  283. 0,
  284. 0,
  285. descriptor.tile_format,
  286. )
  287. # Local
  288. if os.path.exists(source_path):
  289. try:
  290. source_image = PIL.Image.open(safe_open(source_path))
  291. except IOError:
  292. warnings.warn("Skipped invalid level: %s" % source_path)
  293. continue
  294. # Remote
  295. else:
  296. if level == self.max_level:
  297. try:
  298. source_image = PIL.Image.open(safe_open(source_path))
  299. except IOError:
  300. warnings.warn("Skipped invalid image: %s" % source_path)
  301. return
  302. # Expected width & height of the tile
  303. e_w, e_h = descriptor.get_dimensions(level)
  304. # Actual width & height of the tile
  305. w, h = source_image.size
  306. # Correct tile because of IIP bug where low-level tiles have
  307. # wrong dimensions (they are too large)
  308. if w != e_w or h != e_h:
  309. # Resize incorrect tile to correct size
  310. source_image = source_image.resize(
  311. (e_w, e_h), DEFAULT_RESIZE_FILTER
  312. )
  313. # Store new dimensions
  314. w, h = e_w, e_h
  315. else:
  316. w = int(math.ceil(w * 0.5))
  317. h = int(math.ceil(h * 0.5))
  318. source_image.thumbnail((w, h), DEFAULT_RESIZE_FILTER)
  319. column, row = self.get_position(i)
  320. x = (column % images_per_tile) * level_size
  321. y = (row % images_per_tile) * level_size
  322. tile_image.paste(source_image, (x, y))
  323. tile_image.save(tile_path)
  325. def get_position(self, z_order):
  326. """Returns position (column, row) from given Z-order (Morton number.)"""
  327. column = 0
  328. row = 0
  329. for i in range(0, 32, 2):
  330. offset = i // 2
  331. # column
  332. column_offset = i
  333. column_mask = 1 << column_offset
  334. column_value = (z_order & column_mask) >> column_offset
  335. column |= column_value << offset
  336. # row
  337. row_offset = i + 1
  338. row_mask = 1 << row_offset
  339. row_value = (z_order & row_mask) >> row_offset
  340. row |= row_value << offset
  341. return int(column), int(row)
  343. def get_z_order(self, column, row):
  344. """Returns the Z-order (Morton number) from given position."""
  345. z_order = 0
  346. for i in range(32):
  347. z_order |= (column & 1 << i) << i | (row & 1 << i) << (i + 1)
  348. return z_order
  350. def get_tile_position(self, z_order, level, tile_size):
  351. level_size = 2 ** level
  352. x, y = self.get_position(z_order)
  353. return (
  354. int(math.floor((x * level_size) / tile_size)),
  355. int(math.floor((y * level_size) / tile_size)),
  356. )
  359. class DeepZoomCollectionItem(object):
  360. def __init__(self, source, width, height, id=0):
  361. self.id = id
  362. self.source = source
  363. self.width = width
  364. self.height = height
  366. @classmethod
  367. def from_xml(cls, xml):
  368. id = int(xml.getAttribute("Id"))
  369. source = xml.getAttribute("Source")
  370. size = xml.getElementsByTagName("Size")[0]
  371. width = int(size.getAttribute("Width"))
  372. height = int(size.getAttribute("Height"))
  373. return DeepZoomCollectionItem(source, width, height, id)
  376. class ImageCreator(object):
  377. """Creates Deep Zoom images."""
  379. def __init__(
  380. self,
  381. tile_size=254,
  382. tile_overlap=1,
  383. tile_format="jpg",
  384. image_quality=0.8,
  385. resize_filter=None,
  386. copy_metadata=False,
  387. ):
  388. self.tile_size = int(tile_size)
  389. self.tile_format = tile_format
  390. self.tile_overlap = _clamp(int(tile_overlap), 0, 10)
  391. self.image_quality = _clamp(image_quality, 0, 1.0)
  392. if not tile_format in IMAGE_FORMATS:
  393. self.tile_format = DEFAULT_IMAGE_FORMAT
  394. self.resize_filter = resize_filter
  395. self.copy_metadata = copy_metadata
  397. def get_image(self, level):
  398. """Returns the bitmap image at the given level."""
  399. assert (
  400. 0 <= level and level < self.descriptor.num_levels
  401. ), "Invalid pyramid level"
  402. width, height = self.descriptor.get_dimensions(level)
  403. # don't transform to what we already have
  404. if self.descriptor.width == width and self.descriptor.height == height:
  405. return self.image
  406. if (self.resize_filter is None) or (self.resize_filter not in RESIZE_FILTERS):
  407. return self.image.resize((width, height), DEFAULT_RESIZE_FILTER)
  408. return self.image.resize((width, height), RESIZE_FILTERS[self.resize_filter])
  410. def tiles(self, level):
  411. """Iterator for all tiles in the given level. Returns (column, row) of a tile."""
  412. columns, rows = self.descriptor.get_num_tiles(level)
  413. for column in range(columns):
  414. for row in range(rows):
  415. yield (column, row)
  417. def create(self, source, destination):
  418. """Creates Deep Zoom image from source file and saves it to destination."""
  419. if isinstance(source, PIL.Image.Image):
  420. self.image = source
  421. else:
  422. self.image = PIL.Image.open(safe_open(source))
  423. width, height = self.image.size
  424. self.descriptor = DeepZoomImageDescriptor(
  425. width=width,
  426. height=height,
  427. tile_size=self.tile_size,
  428. tile_overlap=self.tile_overlap,
  429. tile_format=self.tile_format,
  430. )
  431. # Create tiles
  432. image_files = _get_or_create_path(_get_files_path(destination))
  433. for level in range(self.descriptor.num_levels):
  434. level_dir = _get_or_create_path(os.path.join(image_files, str(level)))
  435. level_image = self.get_image(level)
  436. for (column, row) in self.tiles(level):
  437. bounds = self.descriptor.get_tile_bounds(level, column, row)
  438. tile = level_image.crop(bounds)
  439. format = self.descriptor.tile_format
  440. tile_path = os.path.join(level_dir, "%s_%s.%s" % (column, row, format))
  441. if self.descriptor.tile_format == "jpg":
  442. jpeg_quality = int(self.image_quality * 100)
  443. tile.save(tile_path, "JPEG", quality=jpeg_quality)
  444. else:
  445. tile.save(tile_path)
  446. # Create descriptor
  447. self.descriptor.save(destination)
  450. class CollectionCreator(object):
  451. """Creates Deep Zoom collections."""
  453. def __init__(
  454. self,
  455. image_quality=0.8,
  456. tile_size=256,
  457. max_level=7,
  458. tile_format="jpg",
  459. copy_metadata=False,
  460. tile_background_color="#000000",
  461. ):
  462. self.image_quality = image_quality
  463. self.tile_size = tile_size
  464. self.max_level = max_level
  465. self.tile_format = tile_format
  466. self.tile_background_color = tile_background_color
  467. # TODO
  468. self.copy_metadata = copy_metadata
  470. def create(self, images, destination):
  471. """Creates a Deep Zoom collection from a list of images."""
  472. collection = DeepZoomCollection(
  473. destination,
  474. image_quality=self.image_quality,
  475. max_level=self.max_level,
  476. tile_size=self.tile_size,
  477. tile_format=self.tile_format,
  478. tile_background_color=self.tile_background_color,
  479. )
  480. for image in images:
  481. collection.append(image)
  482. collection.save()
  485. ################################################################################
  488. def retry(attempts, backoff=2):
  489. """Retries a function or method until it returns or
  490. the number of attempts has been reached."""
  492. if backoff <= 1:
  493. raise ValueError("backoff must be greater than 1")
  495. attempts = int(math.floor(attempts))
  496. if attempts < 0:
  497. raise ValueError("attempts must be 0 or greater")
  499. def deco_retry(f):
  500. def f_retry(*args, **kwargs):
  501. last_exception = None
  502. for _ in range(attempts):
  503. try:
  504. return f(*args, **kwargs)
  505. except Exception as exception:
  506. last_exception = exception
  507. time.sleep(backoff ** (attempts + 1))
  508. raise last_exception
  510. return f_retry
  512. return deco_retry
  515. def _get_or_create_path(path):
  516. if not os.path.exists(path):
  517. os.makedirs(path)
  518. return path
  521. def _clamp(val, min, max):
  522. if val < min:
  523. return min
  524. elif val > max:
  525. return max
  526. return val
  529. def _get_files_path(path):
  530. return os.path.splitext(path)[0] + "_files"
  533. def _remove(path):
  534. os.remove(path)
  535. tiles_path = _get_files_path(path)
  536. shutil.rmtree(tiles_path)
  539. @retry(3)
  540. def safe_open(path):
  541. # `urllib` in Python 2 supported both local paths as well as URLs. To
  542. # continue this in Python 3, we manually add `file://` prefix if `path` is
  543. # not a URL. This change is isolated to this function as we want the output
  544. # XML to still have the original input paths instead of absolute paths:
  545. has_scheme = bool(urlparse(path).scheme)
  546. normalized_path = ("file://%s" % os.path.abspath(path)) if not has_scheme else path
  547. return io.BytesIO(urllib.request.urlopen(normalized_path).read())
  550. ################################################################################
  553. def main():
  554. parser = optparse.OptionParser(usage="Usage: %prog [options] filename")
  556. parser.add_option(
  557. "-d",
  558. "--destination",
  559. dest="destination",
  560. help="Set the destination of the output.",
  561. )
  562. parser.add_option(
  563. "-s",
  564. "--tile_size",
  565. dest="tile_size",
  566. type="int",
  567. default=254,
  568. help="Size of the tiles. Default: 254",
  569. )
  570. parser.add_option(
  571. "-f",
  572. "--tile_format",
  573. dest="tile_format",
  574. default=DEFAULT_IMAGE_FORMAT,
  575. help="Image format of the tiles (jpg or png). Default: jpg",
  576. )
  577. parser.add_option(
  578. "-o",
  579. "--tile_overlap",
  580. dest="tile_overlap",
  581. type="int",
  582. default=1,
  583. help="Overlap of the tiles in pixels (0-10). Default: 1",
  584. )
  585. parser.add_option(
  586. "-q",
  587. "--image_quality",
  588. dest="image_quality",
  589. type="float",
  590. default=0.8,
  591. help="Quality of the image output (0-1). Default: 0.8",
  592. )
  593. parser.add_option(
  594. "-r",
  595. "--resize_filter",
  596. dest="resize_filter",
  597. default=DEFAULT_RESIZE_FILTER,
  598. help="Type of filter for resizing (bicubic, nearest, bilinear, lanczos (best). Default: lanczos",
  599. )
  601. (options, args) = parser.parse_args()
  603. if not args:
  604. parser.print_help()
  605. sys.exit(1)
  607. source = args[0]
  609. if not options.destination:
  610. if os.path.exists(source):
  611. options.destination = os.path.splitext(source)[0] + ".dzi"
  612. else:
  613. options.destination = os.path.splitext(os.path.basename(source))[0] + ".dzi"
  614. if options.resize_filter and options.resize_filter in RESIZE_FILTERS:
  615. options.resize_filter = RESIZE_FILTERS[options.resize_filter]
  617. creator = ImageCreator(
  618. tile_size=options.tile_size,
  619. tile_format=options.tile_format,
  620. image_quality=options.image_quality,
  621. resize_filter=options.resize_filter,
  622. )
  623. creator.create(source, options.destination)
  626. if __name__ == "__main__":
  627. main()

__init__.py at commit 57d62ec, under BSD-3-Clause · at the source

Overview

Authors: Tam Dao1,2, Thanh T. Nguyen1,3, Gia Minh Hoang1,4, Junhyeon Park1, Yunju Jo1,5, Thach Hoang Ngoc6, Diep Hong Pho6, Dien Tran Minh3,6, Emma Anh Ton7, Sunjae Lee8, Hyun Jin Kim2, Vu Chi Dung3,9, Jae Gwan Kim1, Dongryeol Ryu1
ORCID iDs: Gia Minh Hoang, Junhyeon Park, Jae Gwan Kim
  1. Department of Biomedical Science and Engineering Gwangju Institute of Science and Technology (GIST) Gwangju Republic of Korea
  2. Department of Physiology Sungkyunkwan University School of Medicine Suwon Republic of Korea
  3. Center of Endocrinology, Metabolism, Genetic/Genomics and Molecular Therapy Vietnam National Children's Hospital Hanoi Vietnam
  4. Department of Physiology and Biomedical Engineering Mayo Clinic Scottsdale Arizona USA
  5. Department of Microbiology Wonkwang University School of Medicine Iksan Republic of Korea
  6. Department of Pathology Vietnam National Children's Hospital Ha Noi Vietnam
  7. Department of Computer Science Harvard John A. Paulson School of Engineering and Applied Sciences Boston Massachusetts USA
  8. Graduate School of Engineering Biology Korea Advanced Institute of Science & Technology (KAIST) Daejeon Republic of Korea
  9. Department of Pediatrics University of Medicine and Pharmacy—Vietnam National University Ha Noi Vietnam
Institutions: Gwangju Institute of Science and Technology (South Korea); Sungkyunkwan University (South Korea); Vietnam National Children's Hospital (Vietnam); Mayo Clinic in Arizona (United States); Wonkwang University (South Korea); Harvard University (United States); Korea Advanced Institute of Science and Technology (South Korea); Vietnam National University, Hanoi (Vietnam); VNU University of Medicine and Pharmacy (Vietnam)
Journal: Aging cell, volume 25, issue 6, article e70577
Dates: received 17 January 2026; accepted 1 June 2026; published online 15 June 2026; in print June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1111/acel.70577 · PMID 42295036 · PMCID PMC13267430 · OpenAlex W7164832679
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), histology / microscopy (modality), human (organism), other condition (population), cellular / molecular (subfield)
Methods: Statistics, Machine learning
Keywords: cellular senescence, deep learning, nuclear enlargement, skeletal muscle aging, transcriptomics
MeSH: Aging*, Cell Nucleus*, Deep Learning*, Muscle, Skeletal*, Myositis*, Female, Humans (* major topic)
Topic: Muscle Physiology and Disorders (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Ministry of Health and Welfare (RS‐2024‐00507256); National Research Foundation of Korea (NRF) (RS‐2021‐NR060106)
Citations: not cited yet (Europe PMC); 41 references in the paper

Abstract

Aging reshapes the architecture of human skeletal muscle, yet objective tissue‐level markers that capture this process remain limited. We combined large‐scale histology with deep learning to identify reproducible features of muscle aging and to test their biological relevance. We analyzed 974 hematoxylin–eosin whole‐slide images from a population resource using a dual‐attention convolutional neural network and an independent Mask R‐CNN model to quantify nuclear size and density, verified by manual review. The classifier distinguished young from aged muscle with high accuracy (AUC 0.91; accuracy 86.2%), and attention maps consistently highlighted nuclear enlargement and spatial disorganization as salient features. Nuclear diameter increased with age (Spearman's ρ = 0.71, p < 0.0001) across automated and manual measurements. Transcriptomes matched to the same donors showed that samples with larger nuclei were enriched for pathways related to chromatin remodeling, proteostasis, cellular senescence, mitochondrial activity, and telomere regulation, whereas smaller nuclei aligned with anti‐inflammatory and DNA repair programs. External pediatric inflammatory myopathies exhibited nuclear enlargement comparable to aged muscle, suggesting inflammation‐related premature histologic aging. These findings identify nuclear enlargement as a robust, quantifiable feature that integrates structural and molecular signatures of muscle aging. The proposed deep learning–based nuclear morphometry provides a scalable framework for tissue‐level aging biomarkers and suggests a potential “muscle aging clock” applicable to both physiological aging and disease states.

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

Repositories

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

openzoom/deepzoom.py

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 57d62ec36769996458af1351e102e22058bf6369, 16 April 2026
Languages: Python (4), Shell (1)
Size: 14 files, 5 scripts
Software Heritage: archived
Found in: the text, “Hospital Histological Sample Collection”
Holds: README, license file, environment (setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: Pillow (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
7 files
At the source: github.com/openzoom/deepzoom.py

tamdao216/nuclei

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7c560ceb25530186d337e0f74c6140d8e4ad0433, 29 April 2026
Languages: Python (2)
Size: 3 files, 2 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (1 file), OpenCV (1 file), Pillow (1 file), PyTorch (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/tamdao216/nuclei

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

Tracing map

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

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 7 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 data that support the findings of this study are available in Genotype‐Tissue Expression (GTEx) at https://www.gtexportal.org/home/. These data were derived from the following resources available in the public domain: GTEx Histology Viewer, https://www.gtexportal.org/home/histologyPage. Representative raw images, processed data, and Supporting Information have been deposited in Figshare (link (https://figshare.com/articles/figure/high-resolution_images/31999848)). All clinical data and histological images are subject to strict institutional governance and privacy protection policies. Access to these materials may be granted only upon formal request and approval by the Vietnam National Children's Hospital (VNCH), in accordance with institutional and ethical regulations.

Code Availability Statement: All analysis code, pretrained models, and relevant implementation details are publicly available on GitHub (link Github (https://github.com/tamdao216/nuclei)). These materials are freely accessible for academic research and reproducibility purposes. Any additional information or clarification required to reproduce the analyses can be obtained from the corresponding author upon reasonable request.

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

Versions

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

Version 1, 27 September 2026: the first record

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

Cite

This paper

Dao, T., Nguyen, T. T., Hoang, G. M., Park, J., Jo, Y., Ngoc, T. H., Pho, D. H., Minh, D. T., Ton, E. A., Lee, S., Kim, H. J., Dung, V. C., Kim, J. G., & Ryu, D. (2026). Nuclear Enlargement as a Histological Hallmark of Skeletal Muscle Aging, Revealed by Deep Learning-Driven Analysis and Validated in Inflammatory Myopathies. Aging cell, 25(6), e70577. https://doi.org/10.1111/acel.70577

BibTeX

@article{dao2026nuclear,
author = {Dao, Tam and Nguyen, Thanh T. and Hoang, Gia Minh and Park, Junhyeon and Jo, Yunju and Ngoc, Thach Hoang and Pho, Diep Hong and Minh, Dien Tran and Ton, Emma Anh and Lee, Sunjae and Kim, Hyun Jin and Dung, Vu Chi and Kim, Jae Gwan and Ryu, Dongryeol},
title = {{Nuclear Enlargement as a Histological Hallmark of Skeletal Muscle Aging, Revealed by Deep Learning-Driven Analysis and Validated in Inflammatory Myopathies}},
journal = {Aging cell},
year = {2026},
month = jun,
volume = {25},
number = {6},
pages = {e70577},
publisher = {Wiley},
issn = {1474-9718},
doi = {10.1111/acel.70577},
url = {https://doi.org/10.1111/acel.70577},
pmid = {42295036},
pmcid = {PMC13267430}
}

RIS

TY - JOUR
AU - Dao, Tam
AU - Nguyen, Thanh T.
AU - Hoang, Gia Minh
AU - Park, Junhyeon
AU - Jo, Yunju
AU - Ngoc, Thach Hoang
AU - Pho, Diep Hong
AU - Minh, Dien Tran
AU - Ton, Emma Anh
AU - Lee, Sunjae
AU - Kim, Hyun Jin
AU - Dung, Vu Chi
AU - Kim, Jae Gwan
AU - Ryu, Dongryeol
TI - Nuclear Enlargement as a Histological Hallmark of Skeletal Muscle Aging, Revealed by Deep Learning-Driven Analysis and Validated in Inflammatory Myopathies
T2 - Aging cell
J2 - Aging Cell
PY - 2026
DA - 2026/06/01
VL - 25
IS - 6
SP - e70577
SN - 1474-9718
PB - Wiley
DO - 10.1111/acel.70577
UR - https://doi.org/10.1111/acel.70577
LA - en
ER -

CSL-JSON

{
"id": "10.1111/acel.70577",
"type": "article-journal",
"title": "Nuclear Enlargement as a Histological Hallmark of Skeletal Muscle Aging, Revealed by Deep Learning-Driven Analysis and Validated in Inflammatory Myopathies",
"container-title": "Aging cell",
"author": [
{
"family": "Dao",
"given": "Tam"
},
{
"family": "Nguyen",
"given": "Thanh T."
},
{
"family": "Hoang",
"given": "Gia Minh"
},
{
"family": "Park",
"given": "Junhyeon"
},
{
"family": "Jo",
"given": "Yunju"
},
{
"family": "Ngoc",
"given": "Thach Hoang"
},
{
"family": "Pho",
"given": "Diep Hong"
},
{
"family": "Minh",
"given": "Dien Tran"
},
{
"family": "Ton",
"given": "Emma Anh"
},
{
"family": "Lee",
"given": "Sunjae"
},
{
"family": "Kim",
"given": "Hyun Jin"
},
{
"family": "Dung",
"given": "Vu Chi"
},
{
"family": "Kim",
"given": "Jae Gwan"
},
{
"family": "Ryu",
"given": "Dongryeol"
}
],
"container-title-short": "Aging Cell",
"volume": "25",
"issue": "6",
"page": "e70577",
"DOI": "10.1111/acel.70577",
"PMID": "42295036",
"PMCID": "PMC13267430",
"ISSN": "1474-9718",
"publisher": "Wiley",
"URL": "https://doi.org/10.1111/acel.70577",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
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.1371/journal.pone.0344600 [code]
Robust disease prognosis via diagnostic knowledge preservation: A sequential learning approach.
Journal: PloS one
In common: OpenCV, scikit-image, Pillow, 2 other tools, other condition, 2 references
[2] doi:10.1002/alz.71649 [code]
Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy, other condition, cellular / molecular
[3] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: OpenCV, scikit-image, Pillow, 2 other tools, 1 reference
[4] doi:10.1016/j.patter.2026.101538 [code]
A multi-modal foundation model for brain disease diagnosis and medical imaging.
Journal: Patterns (New York, N.Y.)
In common: OpenCV, scikit-image, Pillow, 2 other tools, 1 reference
[5] doi:10.1038/s41598-026-61605-4 [code]
Learning precise segmentation of neurofibrillary tangles from rapid manual point annotations.
Journal: Scientific reports
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy, other condition
[6] doi:10.1038/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy, other condition
[7] doi:10.1007/s00429-026-03166-w [code]
Autoencoders for unsupervised analysis of rat myeloarchitecture.
Journal: Brain structure & function
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy, cellular / molecular
[8] 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, Pillow, 2 other tools, histology / microscopy, cellular / molecular
[9] doi:10.1038/s41467-026-73045-9 [code]
Aberration-aware 3D localization microscopy via self-supervised neural-physics learning.
Journal: Nature communications
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy, cellular / molecular
[10] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: OpenCV, scikit-image, Pillow, 2 other tools, histology / microscopy

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.