OSCR

A Machine learning pipeline to investigate tissue ingrowth in cerebral aneurysms using preclinical animal models.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § Results › Performance Evaluation of the Machine Learning Pipeline ↔ IngrownSegment/codes/IngrownSegUtils.py, lines 161–224 · score 0.51 · ground truth masks, MSE, squared, recall, Dice, precision
  2. [2] § Results › Performance Evaluation of the Machine Learning Pipeline ↔ IngrownSegment/codes/Segmentation_Metrics_Pytorch/metric.py, lines 6–136 · score 0.50 · ground truth, 0–1, Recall, metrics, Dice, precision

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 · 453 lines · 17 KB · Apache · 1 match

  1. """
  2. Created on Wed Nov 27 11:30:00 2024
  4. @author: fafsari
  6. Utilities included here for collagen segmentation task.
  8. This includes:
  10. output figure generation,
  11. metrics calculation,
  12. etc.
  15. """
  16. import os
  17. import torch
  18. import numpy as np
  19. # import matplotlib.pyplot as plt
  21. import cv2
  22. from skimage import filters
  24. # from Segmentation_Metrics_Pytorch.metric import BinaryMetrics
  25. from skimage.transform import resize
  26. from skimage.color import rgb2gray, rgb2lab, lab2rgb
  28. def back_to_reality(tar):
  30. # Getting target array into right format
  31. classes = np.shape(tar)[-1]
  32. dummy = np.zeros((np.shape(tar)[0],np.shape(tar)[1]))
  33. for value in range(classes):
  34. mask = np.where(tar[:,:,value]!=0)
  35. dummy[mask] = value
  37. return dummy
  39. def apply_colormap(img):
  41. n_classes = np.shape(img)[-1]
  43. if n_classes==2:
  44. image = img[:,:,1]
  45. else:
  46. image = img[:,:,0]
  47. for cl in range(1,n_classes):
  48. image = np.concatenate((image, img[:,:,cl]),axis = 1)
  50. return image
  52. # def visualize_multi_task(images,output_type):
  54. # n = len(images)
  56. # if output_type=='comparison':
  57. # fig = plt.figure(constrained_layout = True)
  58. # subfigs = fig.subfigures(1,3)
  59. # image_keys = list(images.keys())
  60. # for outer_ind,subfig in enumerate(subfigs.flat):
  62. # current_key = image_keys[outer_ind]
  64. # subfig.suptitle(current_key)
  66. # if len(images[current_key].shape)==4:
  67. # img = images[current_key][0,:,:,:]
  68. # else:
  69. # img = images[current_key]
  71. # if np.shape(img)[0]<np.shape(img)[-1]:
  72. # img = np.moveaxis(img,source=0,destination=-1)
  73. # img = np.float32(img)
  75. # if image_keys[outer_ind]=='Image':
  76. # img_ax = subfig.add_subplot(1,1,1)
  77. # img_ax.imshow(img)
  78. # else:
  79. # neg_img = np.uint8(255*np.round(img[:,:,0]))
  80. # coll_img = np.uint8(255*img[:,:,1])
  83. # axs = subfig.subplots(1,2)
  84. # titles = ['Continuous','Binary']
  85. # sub_imgs = [coll_img,neg_img]
  86. # cmaps = ['jet','jet']
  87. # for innerind,ax in enumerate(axs.flat):
  88. # ax.set_title(current_key+'_'+titles[innerind])
  89. # ax.set_xticks([])
  90. # ax.set_yticks([])
  92. # ax.imshow(sub_imgs[innerind],cmap=cmaps[innerind])
  94. # elif output_type=='prediction':
  95. # pred_mask = images['Pred_Mask']
  97. # if len(np.shape(pred_mask))==4:
  98. # pred_mask = pred_mask[0,:,:,:]
  100. # pred_mask = np.float32(pred_mask)
  102. # if np.shape(pred_mask)[0]<np.shape(pred_mask)[-1]:
  103. # pred_mask = np.moveaxis(pred_mask,source=0,destination = -1)
  105. # neg_output = 255*np.round(pred_mask[:,:,0])
  106. # coll_output = 255*pred_mask[:,:,1]
  108. # #print(f'Collagen min/max: {np.min(coll_output)},{np.max(coll_output)}')
  109. # #print(f'Negative image min/max: {np.min(neg_output)},{np.max(neg_output)}')
  111. # fig = [coll_output,neg_output]
  113. # return fig
  115. # def visualize_continuous(images,output_type):
  117. # if output_type=='comparison':
  118. # n = len(images)
  119. # for i,key in enumerate(images):
  121. # plt.subplot(1,n,i+1)
  122. # plt.xticks([])
  123. # plt.yticks([])
  124. # plt.title(key)
  126. # if len(np.shape(images[key])) == 4:
  127. # img = images[key][0,:,:,:]
  128. # else:
  129. # img = images[key]
  131. # img = np.float32(img)
  133. # if np.shape(img)[0]<np.shape(img)[-1]:
  134. # img = np.moveaxis(img,source=0,destination=-1)
  136. # if key == 'Pred_Mask' or key == 'Ground_Truth':
  137. # img = apply_colormap(img)
  139. # plt.imshow(img,cmap='jet')
  140. # else:
  141. # # print("Image shape:", img.shape, key)
  142. # plt.imshow(img)
  143. # output_fig = plt.gcf()
  145. # elif output_type=='prediction':
  146. # pred_mask = images['Pred_Mask']
  148. # if len(np.shape(pred_mask))==4:
  149. # pred_mask = pred_mask[0,:,:,:]
  151. # pred_mask = np.float32(pred_mask)
  153. # if np.shape(pred_mask)[0]<np.shape(pred_mask)[-1]:
  154. # pred_mask = np.moveaxis(pred_mask,source=0,destination = -1)
  156. # output_fig = apply_colormap(pred_mask)
  159. # return output_fig
  161. def get_metrics(pred_mask,ground_truth,img_name,calculator,target_type):
  163. metrics_row = {}
  165. if target_type=='binary':
  166. edited_gt = ground_truth[:,1,:,:]
  167. edited_gt = torch.unsqueeze(edited_gt,dim = 1)
  168. edited_pred = pred_mask[:,1,:,:]
  169. edited_pred = torch.unsqueeze(edited_pred,dim = 1)
  171. #print(f'edited pred_mask shape: {edited_pred.shape}')
  172. #print(f'edited ground_truth shape: {edited_gt.shape}')
  173. #print(f'Unique values prediction mask : {torch.unique(edited_pred)}')
  174. #print(f'Unique values ground truth mask: {torch.unique(edited_gt)}')
  176. acc, dice, precision, recall,specificity = calculator(edited_gt,torch.round(edited_pred))
  177. metrics_row['Accuracy'] = [round(acc.numpy().tolist(),4)]
  178. metrics_row['Dice'] = [round(dice.numpy().tolist(),4)]
  179. metrics_row['Precision'] = [round(precision.numpy().tolist(),4)]
  180. metrics_row['Recall'] = [round(recall.numpy().tolist(),4)]
  181. metrics_row['Specificity'] = [round(specificity.numpy().tolist(),4)]
  183. #print(metrics_row)
  184. elif target_type == 'nonbinary':
  185. square_diff = (ground_truth.numpy()-pred_mask.numpy())**2
  186. mse = np.mean(square_diff)
  188. norm_mse = (square_diff-np.min(square_diff))/np.max(square_diff)
  189. norm_mse = np.mean(norm_mse)
  191. metrics_row['MSE'] = [round(mse,4)]
  192. metrics_row['Norm_MSE']=[round(norm_mse,4)]
  194. elif target_type == 'multi_task':
  195. bin_gt = ground_truth[:,0,:,:]
  196. bin_gt = torch.squeeze(bin_gt)
  197. bin_pred = pred_mask[0,:,:]
  200. acc, dice, precision, recall, sensitivity = calculator(bin_gt,torch.round(bin_pred))
  201. metrics_row['Accuracy'] = [round(acc.numpy().tolist(),4)]
  202. metrics_row['Dice'] = [round(dice.numpy().tolist(),4)]
  203. metrics_row['Precision'] = [round(precision.numpy().tolist(),4)]
  204. metrics_row['Recall'] = [round(recall.numpy().tolist(),4)]
  205. metrics_row['Specificity'] = [round(specificity.numpy().tolist(),4)]
  206. metrics_row['Sensitivity'] = [round(sensitivity.numpy().tolist(),4)]
  208. reg_gt = ground_truth[:,1,:,:]
  209. reg_gt = torch.squeeze(reg_gt)
  210. reg_pred = pred_mask[1,:,:]
  212. square_diff = (reg_gt.numpy()-reg_pred.numpy())**2
  213. mse = np.mean(square_diff)
  215. norm_mse = (square_diff-np.min(square_diff))/np.max(square_diff)
  216. norm_mse = np.mean(norm_mse)
  218. metrics_row['MSE'] = [round(mse,4)]
  219. metrics_row['Norm_MSE'] = [round(norm_mse,4)]
  222. metrics_row['ImgLabel'] = img_name
  224. return metrics_row
  226. # Function to resize and apply any condensing transform like grayscale conversion
  227. def resize_special(img,output_size,transform):
  229. # multi-image input transform
  230. if 'multi_input' in transform:
  231. if transform =='multi_input_invbf':
  232. # Inverting brightfield channels
  233. img = resize(img,output_shape=(output_size))
  235. f_img = img[:,:,0:3]
  236. f_img = f_img/np.sum(f_img,axis=-1)[:,:,None]
  237. b_img = 255-img[:,:,2:5]
  238. b_img = b_img/np.sum(b_img,axis=-1)[:,:,None]
  240. img = np.concatenate((f_img,b_img),axis=-1)
  241. elif transform =='multi_input_green_invbf':
  242. # Green channels, inverting bf
  243. #img = resize(img, output_shape = (output_size))
  245. f_img = img[:,:,1]
  246. f_img = (f_img - np.min(f_img))/np.ptp(f_img)
  248. b_img = 255-img[:,:,4]
  249. b_img = (b_img - np.min(b_img))/np.ptp(b_img)
  251. img = np.concatenate((f_img[:,:,None],b_img[:,:,None]),axis=-1)
  252. #img = resize(img,output_shape = (output_size))
  253. elif transform == 'multi_input_mean_invbf':
  255. # Mean of color channels, inverting bf
  256. f_img = np.mean(img[:,:,0:3],axis=-1)
  257. f_img = (f_img - np.min(f_img))/np.ptp(f_img)
  259. b_img = 255-np.mean(img[:,:,2:5],axis=-1)
  260. b_img = (b_img - np.min(b_img))/np.ptp(b_img)
  262. img = np.concatenate((f_img[:,:,None],b_img[:,:,None]),axis=-1)
  264. elif transform=='multi_input_green':
  266. # Grabbing green channels without inverting
  267. f_img = img[:,:,1]
  268. b_img = img[:,:,4]
  270. img = np.concatenate((f_img[:,:,None],b_img[:,:,None]),axis=-1)
  272. elif transform == 'multi_input_mean':
  274. # Grabbing mean of brightfield and fluorescent images and concatenating them
  275. f_img = np.mean(img[:,:,0:3], axis=-1)
  276. b_img = np.mean(img[:,:,2:5], axis=-1)
  277. # print(f"shape: {f_img}, {b_img}, {f_img.shape}, {b_img.shape}")
  278. img = np.concatenate((f_img[:,:,None],b_img[:,:,None]),axis=-1)
  280. else:
  281. if transform=='mean':
  283. img = np.mean(img,axis = -1)
  284. img = img[:,:,np.newaxis]
  286. elif transform in ['red','green','blue']:
  288. color_list = ['red','green','blue']
  289. img = img[:,:,color_list.index(transform)]
  290. img = img[:,:,np.newaxis]
  292. elif transform == 'rgb2gray':
  294. img = rgb2gray(img)
  295. img = img[:,:,np.newaxis]
  297. elif transform == 'rgb2lab':
  299. img = rgb2lab(img)
  301. elif type(transform)==dict:
  303. # Determining non-tissue regions to mask out prior to scaling/conversion
  304. # For BF images the non-tissue regions are closer to white whereas with fluorescence images they
  305. # are closer to black
  307. lab_img = rgb2lab(img)
  308. scaled_img = (lab_img-np.nanmean(lab_img))/np.nanstd(lab_img)
  310. for i in range(3):
  311. scaled_img[:,:,i] = scaled_img[:,:,i]*transform['norm_std'][i]+transform['norm_mean'][i]
  313. # converting back to rgb
  314. img = (scaled_img-np.nanmean(scaled_img))/np.nanstd(scaled_img)
  316. elif transform == 'invert_bf_intensity':
  317. # Grabbing the green channel from both the fluorescence and brightfield images
  318. f_green_img = img[:,:,1]
  319. f_green_img = np.divide(f_green_img,np.sum(img[:,:,0:3],axis=-1),where=(np.sum(img[:,:,0:3],axis=-1)!=0))
  320. # Inverting brightfield channels
  321. b_green_inv_img = 255-img[:,:,3]
  322. b_green_inv_img = np.divide(b_green_inv_img,np.sum(255-img[:,:,2:5],axis=-1),where=(np.sum(255-img[:,:,2:5],axis=-1)!=0))
  323. img = np.concatenate((f_green_img[:,:,None],b_green_inv_img[:,:,None]),axis=-1)
  325. elif transform == 'invert_bf_01norm':
  327. inv_bf = 255-img[:,:,2:5]
  328. inv_bf_norm = np.divide(inv_bf,np.sum(inv_bf,axis=-1)[:,:,None],where=(np.sum(inv_bf,axis=-1)[:,:,None]!=0))
  329. f_img = img[:,:,0:3]
  330. f_norm = np.divide(f_img,np.sum(f_img,axis=-1)[:,:,None],where=(np.sum(f_img,axis=-1)[:,:,None]!=0))
  332. img = np.concatenate((f_norm,inv_bf_norm),axis=-1)
  334. img = np.float32(resize(img,output_size))
  336. return img
  339. def loop_iterable(iterable):
  340. while True:
  341. yield from iterable
  344. def set_requires_grad(model, requires_grad=True):
  345. for param in model.parameters():
  346. param.requires_grad = requires_grad
  349. def calcIngrown_plot(img_name, test_name, gt_name, threshold, title='', out_path='', plot_status=True):
  351. if plot_status:
  352. # print(f'Calculating Ingrown Area, plotting is {plot_status}...')
  353. # Read the prediction
  354. test_img = cv2.imread(str(test_name), cv2.IMREAD_GRAYSCALE)
  355. pred_size = (test_img.shape[1], test_img.shape[0]) # (width, height)
  357. # Read and resize the target to the prediction size
  358. tar = cv2.imread(str(gt_name), cv2.IMREAD_GRAYSCALE)
  359. tar = cv2.resize(tar, pred_size, interpolation=cv2.INTER_NEAREST)
  361. threshold = filters.threshold_otsu(test_img)
  363. # Create binary images for mask processing
  364. binary_test = (1/255) * cv2.threshold(test_img, threshold, 255, cv2.THRESH_BINARY)[1]
  366. binary_gt = cv2.threshold(tar, threshold, 255, cv2.THRESH_BINARY)[1]
  367. contours, _ = cv2.findContours(binary_gt, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  368. binary_gt_filled = cv2.fillPoly(binary_gt, pts=contours, color=(255, 255, 255))
  369. binary_gt = (1/255) * binary_gt
  371. else:
  372. # binary_test = cv2.threshold(test_img, threshold*255, 255, cv2.THRESH_BINARY)[1] # test_img
  373. test_img = test_name.copy()
  374. pred_size = test_img.shape # (width, height)
  375. binary_test = test_img.copy()
  376. binary_test[test_img < threshold] = 0
  377. binary_test[test_img >= threshold] = 1
  378. binary_gt = gt_name.copy()
  380. # Read and resize the image to the prediction size
  381. img = cv2.cvtColor(cv2.imread(str(img_name), cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)
  382. img = cv2.resize(img, pred_size, interpolation=cv2.INTER_LINEAR)
  384. # Create binary images for mask processing
  385. gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
  386. if plot_status:
  387. binary_img = (1/255) * cv2.threshold(gray_img, threshold, 255, cv2.THRESH_BINARY)[1]
  388. else:
  389. binary_img = (1/255) * cv2.threshold(gray_img, threshold*255, 255, cv2.THRESH_BINARY)[1]
  391. binary_gt = binary_gt.astype(np.uint8)
  392. binary_img = binary_img.astype(np.uint8)
  393. binary_test = binary_test.astype(np.uint8)
  395. # Create the ingrown tissue mask using the prediction and the binary mask
  396. # print(f'binary_test unique: {np.unique(binary_test)}, \n binary_img unique: {np.unique(binary_img)}, \n binary_gt unique: {np.unique(binary_gt)}')
  397. ingrown_tissue_test = cv2.bitwise_and(binary_test, binary_img)
  398. ingrown_tissue_gt = cv2.bitwise_and(binary_gt, binary_img)
  399. # ingrown_tissue_test = ingrown_tissue_mask * test_img
  401. # Find ingrown tissue pred and ingrown tissue target images for evaluation
  402. # print(f'binary_gt shape: {binary_gt.shape}, binary_img shape: {binary_img.shape}, binary_test shape: {binary_test.shape}')
  403. # ingrown_tissue_gt = cv2.bitwise_and(binary_gt, binary_img)
  404. # ingrown_tissue_gt = ingrown_tissue_mask
  406. # Calculate the ratio of white pixels in the ingrown tissue mask relative to the total area of the sac zone
  407. total_sac_area_test = cv2.countNonZero(test_img)
  408. ingrown_tissue_area_test = cv2.countNonZero(ingrown_tissue_test * test_img)
  410. # Calculate the ingrown tissue ratio
  411. if total_sac_area_test > 0:
  412. ingrown_tissue_ratio_test = (ingrown_tissue_area_test / total_sac_area_test) * 100 # Percentage
  413. else:
  414. ingrown_tissue_ratio_test = 0
  416. total_sac_area_gt = cv2.countNonZero(binary_gt)
  417. ingrown_tissue_area_gt = cv2.countNonZero(ingrown_tissue_gt * binary_gt)
  419. if total_sac_area_gt > 0:
  420. ingrown_tissue_ratio_gt = (ingrown_tissue_area_gt / total_sac_area_gt) * 100 # Percentage
  421. else:
  422. ingrown_tissue_ratio_gt = 0
  424. # # Calculate the ingrown tissue ratio
  425. # if total_sac_area_test > 0:
  426. # ingrown_tissue_ratio = (ingrown_tissue_area_test / total_sac_area_test) * 100 # Percentage
  427. # else:
  428. # ingrown_tissue_ratio = 0
  430. # Calculate the overlayed image
  431. binary_img_not = cv2.bitwise_not(binary_img)
  432. new_binary_img = gray_img * (binary_img_not)
  434. # Create the ingrown tissue mask using the prediction and the binary mask
  435. # binary_test[binary_test == 1] = 255
  436. ingrown_tissue_mask_test = (binary_test) * new_binary_img
  437. ingrown_tissue_mask_gt = (binary_gt) * new_binary_img
  439. # Save the ingrown tissue mask and overlayed image, and filled tar image
  440. if plot_status:
  441. out_path = out_path + 'Figures'
  442. # print(out_path)
  443. if not os.path.exists(out_path):
  444. os.makedirs(out_path, exist_ok=True)
  446. cv2.imwrite(f'{out_path}/{title}_gt.png', binary_gt_filled)
  447. cv2.imwrite(f'{out_path}/{title}_ingrown_tissue_pred.png', ingrown_tissue_mask_test)
  448. cv2.imwrite(f'{out_path}/{title}_ingrown_tissue_gt.png', ingrown_tissue_mask_gt)
  449. # cv2.imwrite(f'{out_path}/{title}_overlayed_image.png', overlayed_image)
  451. ingrown_test_list = [ingrown_tissue_area_test, total_sac_area_test, ingrown_tissue_ratio_test]
  452. ingrown_gt_list = [ingrown_tissue_area_gt, total_sac_area_gt, ingrown_tissue_ratio_gt]
  453. return ingrown_test_list, ingrown_gt_list, [ingrown_tissue_gt, ingrown_tissue_test]

IngrownSegUtils.py at commit 3f09625, under Apache · at the source

Overview

Authors: Fatemeh Afsari1, Ishaq Ansari1,2, Melanie E Martinez3, Lillian Atchison1, Sayat Mimar1, Koji Hosaka3, Brian Hoh3, Pinaki Sarder1
  1. Division of Nephrology, Hypertension, and Renal Transplantation—Quantitative Health Section, Department of Medicine, College of Medicine, University of Florida, Gainesville, FL 32611 USA
  2. School of Natural Sciences, Caldwell University, Caldwell, NJ 07006 USA
  3. Department of Neurosurgery, College of Medicine, University of Florida, Gainesville, FL 32611 USA
Institutions: University of Florida Health (United States); University of Florida (United States); Caldwell University (United States)
Journal: Scientific reports, volume 16, issue 1, article 13352
Dates: received 6 August 2025; accepted 6 March 2026; published online 13 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41598-026-43798-w · PMID 41826635 · PMCID PMC13106824 · OpenAlex W7135210177
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), mouse (organism), stroke (population), methods / tools (subfield)
Methods: Machine learning
Keywords: Cerebral aneurysm, Tissue ingrowth, Histological image analysis, Unet++, Deep learning, Segmentation, Computational biology and bioinformatics, Engineering, Mathematics and computing, Medical research
MeSH: Intracranial Aneurysm*, Machine Learning*, Animals, Convolutional Neural Networks, Disease Models, Animal, Image Processing, Computer-Assisted, Mice (* major topic)
Topic: Intracranial Aneurysms: Treatment and Complications (Neurology, Medicine), according to OpenAlex
Funding: NIH HHS (R01 NS110710)
Citations: not cited yet (Europe PMC); 49 references in the paper

Abstract

Cerebral aneurysm is a life-threatening condition characterized by the formation of a saccular bulge in brain blood vessels, which can rupture and lead to severe complications. One treatment involves inserting a soft, flexible wire (coil) into the aneurysm to promote clotting and sealing. Mediators are often used to simulate tissue ingrowth within the sac to stabilize healing and prevent recurrence. However, quantitative assessment of tissue ingrowth in preclinical models remains labor-intensive, subjective, and poorly standardized, limiting the ability to compare therapeutic strategies and healing mechanisms. We developed a robust machine learning (ML) pipeline based on a Unet + + convolutional neural network (CNN), optimized for segmenting and quantifying tissue ingrowth in a preclinical carotid aneurysm mouse model. The model was trained and validated on 64 high-resolution histological images using 10-fold cross-validation. Image preprocessing included resizing, normalization, and augmentation, while post-processing applied thresholding techniques to CNN-generated heatmaps. Our method achieved Dice coefficients of 94.58% for sac segmentation and 95.23% for tissue ingrowth detection, with AUCs of 99.24% and 96.78%, respectively. The model’s predictions showed strong agreement with ground truth (), supporting its potential for assessing biological stability and informing clinical decisions. In a blinded evaluation against expert annotations, our AI model achieved the highest agreement (Cohen’s κ) among all raters, demonstrating its potential to provide consistent and expert-level tissue ingrowth assessments. A user-friendly graphical interface was developed, to enable non-technical users to perform segmentation and quantify tissue ingrowth. By providing objective, reproducible metrics of intra-aneurysmal healing, this approach supports mechanistic studies of therapeutic efficacy in preclinical aneurysm models and establishes a foundation for standardized evaluation of pro-healing interventions.

Supplementary Information: The online version contains supplementary material available at 10.1038/s41598-026-43798-w.

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

Repository

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

SarderLab/Ingrowth-Segmentation-DSA-Plugin

License: Apache
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 3f09625763db74703210a69402fb52df91e8530b, 1 August 2025
Languages: Python (13), Shell (1)
Size: 24 files, 14 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (Dockerfile, setup.py)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (7 files), PyTorch (6 files), OpenCV (5 files), scikit-image (4 files), imageio (1 file), pandas (1 file), Pillow (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
16 files
At the source: github.com/SarderLab/Ingrowth-Segmentation-DSA-Plugin

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 14 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data sharing

The Code for the segmentation model plugin is available at the GitHub repository: https://github.com/SarderLab/Ingrowth-Segmentation-DSA-Plugin. The datasets used and analyzed during the current study are available from the corresponding author on 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, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 10 keywords, 7 MeSH terms, 1 funder, 35 references.

Cite

This paper

Afsari, F., Ansari, I., Martinez, M. E., Atchison, L., Mimar, S., Hosaka, K., Hoh, B., & Sarder, P. (2026). A Machine learning pipeline to investigate tissue ingrowth in cerebral aneurysms using preclinical animal models. Scientific reports, 16(1), 13352. https://doi.org/10.1038/s41598-026-43798-w

BibTeX

@article{afsari2026machine,
author = {Afsari, Fatemeh and Ansari, Ishaq and Martinez, Melanie E and Atchison, Lillian and Mimar, Sayat and Hosaka, Koji and Hoh, Brian and Sarder, Pinaki},
title = {{A Machine learning pipeline to investigate tissue ingrowth in cerebral aneurysms using preclinical animal models}},
journal = {Scientific reports},
year = {2026},
month = mar,
volume = {16},
number = {1},
pages = {13352},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-43798-w},
url = {https://doi.org/10.1038/s41598-026-43798-w},
pmid = {41826635},
pmcid = {PMC13106824}
}

RIS

TY - JOUR
AU - Afsari, Fatemeh
AU - Ansari, Ishaq
AU - Martinez, Melanie E
AU - Atchison, Lillian
AU - Mimar, Sayat
AU - Hosaka, Koji
AU - Hoh, Brian
AU - Sarder, Pinaki
TI - A Machine learning pipeline to investigate tissue ingrowth in cerebral aneurysms using preclinical animal models
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/03/13
VL - 16
IS - 1
SP - 13352
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-43798-w
UR - https://doi.org/10.1038/s41598-026-43798-w
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-43798-w",
"type": "article-journal",
"title": "A Machine learning pipeline to investigate tissue ingrowth in cerebral aneurysms using preclinical animal models",
"container-title": "Scientific reports",
"author": [
{
"family": "Afsari",
"given": "Fatemeh"
},
{
"family": "Ansari",
"given": "Ishaq"
},
{
"family": "Martinez",
"given": "Melanie E"
},
{
"family": "Atchison",
"given": "Lillian"
},
{
"family": "Mimar",
"given": "Sayat"
},
{
"family": "Hosaka",
"given": "Koji"
},
{
"family": "Hoh",
"given": "Brian"
},
{
"family": "Sarder",
"given": "Pinaki"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "13352",
"DOI": "10.1038/s41598-026-43798-w",
"PMID": "41826635",
"PMCID": "PMC13106824",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-43798-w",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
13
]
]
}
}

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/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: imageio, OpenCV, scikit-image, 5 other tools, histology / microscopy, methods / tools, mouse
[2] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: imageio, OpenCV, scikit-image, 5 other tools, histology / microscopy, methods / tools
[3] 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, 4 other tools, histology / microscopy, methods / tools, 1 reference
[4] doi:10.1016/j.isci.2026.116168 [code]
See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion.
Journal: iScience
In common: imageio, OpenCV, scikit-image, 5 other tools, methods / tools
[5] doi:10.1038/s41597-026-07248-6 [code]
A large-scale fMRI dataset for vision-language semantic association.
Journal: Scientific data
In common: imageio, OpenCV, scikit-image, 5 other tools, methods / tools
[6] doi:10.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: imageio, OpenCV, scikit-image, 5 other tools, methods / tools
[7] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: imageio, OpenCV, scikit-image, 4 other tools, 1 reference
[8] doi:10.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: imageio, OpenCV, scikit-image, 5 other tools, mouse
[9] doi:10.1038/s41467-026-73373-w [code]
Mapping neuro-vascular unit communications reveals distinct angiogenic programs across developing mouse brain regions.
Journal: Nature communications
In common: imageio, OpenCV, scikit-image, 5 other tools, mouse
[10] 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: imageio, OpenCV, scikit-image, 5 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.