OSCR

BT-CAP: a subcomponent-aware and anatomically constrained data augmentation framework for multi-modal brain tumor MRI segmentation.

Code ↔ Paper

16 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 16 matches
  1. [1] § Materials and methods › Context adaptation › Deforming peritumoral edema with anatomical constraints ↔ src/BT_CAP/edema.py, lines 5–44 · score 0.98 · outer shell, warped edema, map_coordinates, inner edema, displacement field, Gaussian filter
  2. [2] § Materials and methods › Core manipulation › B-spline deformation and reinsertion of tumor subcomponents ↔ src/BT_CAP/deform.py, lines 40–81 · score 0.86 · spline transformations, deformed mask, nearest neighbour, Random displacements, linear, resampled
  3. [3] § Materials and methods › Refinement › Inpainting empty areas in the tumor core ↔ src/BT_CAP/rearrange.py, lines 200–341 · score 0.80 · empty voxels, Gaussian filter, transformed islands, tumor core, placement, filled
  4. [4] § Materials and methods › Core manipulation › Rearranging tumor subcomponents for optimal core coverage ↔ src/BT_CAP/rearrange.py, lines 21–49 · score 0.79 · sub islands, distance transform, Large islands, peaks, watershed, splitting
  5. [5] § Materials and methods › Core manipulation › B-spline deformation and reinsertion of tumor subcomponents ↔ src/BT_CAP/main.py, lines 98–164 · score 0.78 · deformed mask, Random displacements, bounding box, reinserted, physical, rescaled
  6. [6] § Materials and methods › Core manipulation › Rearranging tumor subcomponents for optimal core coverage ↔ src/BT_CAP/rearrange.py, lines 90–141 · score 0.77 · transformed island, bounding box, minimizing, ftol, xtol, mass
  7. [7] § Materials and methods › Refinement › Inpainting empty areas in the tumor core ↔ src/BT_CAP/inpaint.py, lines 7–53 · score 0.77 · empty areas, Gaussian filter, original tumor core, donor, padded, Inpainting
  8. [8] § Results › Anatomical plausibility ↔ src/BT_CAP/edema.py, lines 5–44 · score 0.66 · displacement field, inner edema, edema mask, tumor core, zero, deformed
  9. [9] § Materials and methods › Refinement › Smoothing interfaces and managing outlier intensities ↔ src/BT_CAP/rearrange.py, lines 143–174 · score 0.65 · KD tree, modified, median, outlier, nearest, neighborhood
  10. [10] § Materials and methods › Context adaptation › Deforming peritumoral edema with anatomical constraints ↔ src/BT_CAP/main.py, lines 98–164 · score 0.64 · random displacement, original tumor core, uniformly, deformed, spacing, threshold
  11. [11] § Materials and methods › Core manipulation › Rearranging tumor subcomponents for optimal core coverage ↔ src/BT_CAP/rearrange.py, lines 90–141 · score 0.62 · empty_core, init_shift, clip, bbox, Rearranging, tumor
  12. [12] § Materials and methods › Implementation details ↔ src/BT_CAP/main.py, lines 318–327 · score 0.59 · random seed, BT CAP, Reproducibility, workers, Parallel, augmentation
  13. [13] § Materials and methods › Core manipulation › Rearranging tumor subcomponents for optimal core coverage ↔ src/BT_CAP/rearrange.py, lines 200–341 · score 0.58 · Find single enclosed, empty voxels, filled, neighbours, Rearranging, subcomponents
  14. [14] § Materials and methods › Core manipulation › Extracting tumor subcomponents ↔ src/BT_CAP/extract.py, lines 13–37 · score 0.56 · binary mask, bounding box, cropping, components, voxels, smooth
  15. [15] § Materials and methods › Implementation details ↔ src/BT_CAP/main.py, lines 318–327 · score 0.55 · BT CAP augmentation, random seed, CPU
  16. [16] § Materials and methods › Core manipulation › Rearranging tumor subcomponents for optimal core coverage ↔ src/BT_CAP/rearrange.py, lines 143–174 · score 0.52 · KD tree, NN, outliers, voxels, Rearranging, tumor

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 · 341 lines · 16 KB · MIT · 7 matches

  1. from __future__ import annotations
  2. from .utils import get_bounding_box, smooth_interface_with_kernel
  3. from scipy.ndimage import label, center_of_mass, affine_transform, generate_binary_structure, gaussian_filter, binary_opening, convolve, distance_transform_edt
  4. from scipy.optimize import minimize
  5. from skimage.segmentation import watershed
  6. from skimage.feature import peak_local_max
  7. from sklearn.neighbors import NearestNeighbors
  8. import numpy as np
  10. def extract_sorted_islands(mask: np.ndarray) -> list[np.ndarray]:
  11. labeled, num_features = label(mask.astype(np.uint8))
  12. islands = []
  13. for i in range(1, num_features + 1):
  14. comp = (labeled == i)
  15. cnt = int(comp.sum())
  16. if cnt > 0:
  17. islands.append((cnt, comp))
  18. islands.sort(reverse=True, key=lambda x: x[0])
  19. return [comp for _, comp in islands]
  21. def split_large_island(island: np.ndarray, threshold: int) -> list[tuple[int, np.ndarray]]:
  22. voxel_count = int(island.sum())
  23. if voxel_count <= threshold:
  24. return [(voxel_count, island.astype(np.uint8, copy=False))]
  25. dist = distance_transform_edt(island)
  26. if dist.max() < 1:
  27. return [(voxel_count, island.astype(np.uint8, copy=False))]
  28. coords = peak_local_max(dist, labels=island, num_peaks=2, exclude_border=False)
  29. if coords is None or len(coords) < 2:
  30. return [(voxel_count, island.astype(np.uint8, copy=False))]
  31. markers = np.zeros_like(island, dtype=np.int32)
  32. for i, c in enumerate(coords[:2], start=1):
  33. markers[tuple(c)] = i
  34. labels_ws = watershed(-dist, markers, mask=island)
  35. sub_islands = []
  36. for lbl in (1, 2):
  37. sub = (labels_ws == lbl)
  38. if sub.sum() >= 100:
  39. struct = generate_binary_structure(3, 1)
  40. sub = binary_opening(sub, structure=struct)
  41. cnt = int(sub.sum())
  42. if cnt > 0:
  43. sub_islands.append((cnt, sub.astype(np.uint8, copy=False)))
  44. if len(sub_islands) < 2:
  45. return [(voxel_count, island.astype(np.uint8, copy=False))]
  46. final = []
  47. for cnt, sub in sub_islands:
  48. final.extend(split_large_island(sub, threshold))
  49. return final
  51. def transform_island(
  52. island: np.ndarray,
  53. angles_deg: np.ndarray,
  54. shifts_vox: np.ndarray,
  55. modalities: np.ndarray | None = None,
  56. ) -> tuple[np.ndarray, np.ndarray | None]:
  57. theta_x, theta_y, theta_z = np.deg2rad(angles_deg.astype(float))
  58. Rx = np.array([[1, 0, 0],
  59. [0, np.cos(theta_x), -np.sin(theta_x)],
  60. [0, np.sin(theta_x), np.cos(theta_x)]], dtype=np.float64)
  61. Ry = np.array([[ np.cos(theta_y), 0, np.sin(theta_y)],
  62. [0, 1, 0 ],
  63. [-np.sin(theta_y), 0, np.cos(theta_y)]], dtype=np.float64)
  64. Rz = np.array([[ np.cos(theta_z), -np.sin(theta_z), 0],
  65. [ np.sin(theta_z), np.cos(theta_z), 0],
  66. [0, 0, 1]], dtype=np.float64)
  67. R = Rz @ Ry @ Rx
  68. center = (np.array(island.shape, dtype=np.float64) / 2.0)
  69. shifts = shifts_vox.astype(np.float64)
  70. offset = center - R @ center - shifts
  71. transformed_island = affine_transform(
  72. island.astype(np.float32, copy=False),
  73. R, offset=offset, order=0, mode="constant", cval=0.0, prefilter=False
  74. )
  75. transformed_island = (transformed_island > 0.5).astype(np.uint8)
  76. transformed_modalities = None
  77. if modalities is not None:
  78. C = modalities.shape[0]
  79. out = []
  80. for i in range(C):
  81. ch = affine_transform(
  82. modalities[i].astype(np.float32, copy=False),
  83. R, offset=offset, order=3, mode="constant", cval=0.0, prefilter=True
  84. )
  85. out.append(ch)
  86. transformed_modalities = np.stack(out, axis=0).astype(np.float32, copy=False)
  87. transformed_modalities *= transformed_island[None, ...]
  88. return transformed_island, transformed_modalities
  90. def optimize_island(
  91. island: np.ndarray,
  92. tumor_core: np.ndarray,
  93. covered_core: np.ndarray,
  94. angle_bounds: tuple[float, float] = (-180.0, 180.0),
  95. shift_margin_vox: float | None = None,
  96. maxiter: int = 80,
  97. rng: np.random.Generator = None
  98. ) -> np.ndarray:
  99. empty_core = (tumor_core.astype(bool) & (~covered_core.astype(bool)))
  100. bbox = get_bounding_box(tumor_core, [1])
  101. if bbox is None:
  102. return np.zeros(6, dtype=np.float32)
  103. (z_min, z_max), (y_min, y_max), (x_min, x_max) = bbox
  104. dz, dy, dx = (z_max - z_min), (y_max - y_min), (x_max - x_min)
  105. if shift_margin_vox is None:
  106. shift_margin_vox = 0.5
  107. shift_bounds = np.array([
  108. [-dx * shift_margin_vox, dx * shift_margin_vox],
  109. [-dy * shift_margin_vox, dy * shift_margin_vox],
  110. [-dz * shift_margin_vox, dz * shift_margin_vox],
  111. ], dtype=np.float64)
  112. ang_lo, ang_hi = angle_bounds
  113. angle_bounds_arr = np.array([[ang_lo, ang_hi]] * 3, dtype=np.float64)
  114. com_island = np.array(center_of_mass(island))
  115. if empty_core.any():
  116. com_core = np.array(center_of_mass(empty_core))
  117. else:
  118. com_core = np.array(center_of_mass(tumor_core))
  119. init_shift = (com_core - com_island)
  120. init_shift = np.clip(init_shift, shift_bounds[:, 0], shift_bounds[:, 1])
  121. init_angles = rng.uniform(ang_lo / 4.0, ang_hi / 4.0, size=3)
  122. x0 = np.concatenate([init_angles, init_shift]).astype(np.float64)
  123. def _clamp_params(p: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
  124. a = np.clip(p[:3], angle_bounds_arr[:, 0], angle_bounds_arr[:, 1])
  125. s = np.clip(p[3:], shift_bounds[:, 0], shift_bounds[:, 1])
  126. return a, s
  127. def cost(p: np.ndarray) -> float:
  128. a, s = _clamp_params(p)
  129. t_mask, _ = transform_island(island, a, s)
  130. sz = t_mask.sum()
  131. if sz == 0:
  132. return 1e6
  133. overlap = (t_mask.astype(bool) & empty_core).sum()
  134. score = overlap / float(sz)
  135. return -float(score)
  136. res = minimize(
  137. cost, x0, method="Powell",
  138. options={"maxiter": maxiter, "xtol": 0.2, "ftol": 0.1}
  139. )
  140. a, s = _clamp_params(res.x.astype(np.float64))
  141. return np.concatenate([a, s]).astype(np.float32)
  143. def clean_mask_intensity_knn(volume: np.ndarray, mask: np.ndarray, mad_thresh=3.5, iqr_factor=1.5, k=5):
  144. mask = mask.astype(bool)
  145. tumor_voxels = volume[mask]
  146. if tumor_voxels.size == 0:
  147. return volume.copy(), np.zeros_like(volume, dtype=bool)
  148. tumor_coords = np.argwhere(mask)
  149. median_intensity = np.median(tumor_voxels)
  150. mad = np.median(np.abs(tumor_voxels - median_intensity))
  151. if mad > 0:
  152. modified_z = 0.6745 * (tumor_voxels - median_intensity) / mad
  153. out_idx = np.where(np.abs(modified_z) > mad_thresh)[0]
  154. else:
  155. q1, q3 = np.percentile(tumor_voxels, [25, 75])
  156. iqr = q3 - q1
  157. lo, hi = q1 - iqr_factor * iqr, q3 + iqr_factor * iqr
  158. out_idx = np.where((tumor_voxels < lo) | (tumor_voxels > hi))[0]
  159. outlier_mask = np.zeros_like(volume, dtype=bool)
  160. if out_idx.size == 0:
  161. return volume.copy(), outlier_mask
  162. outlier_coords = tumor_coords[out_idx]
  163. outlier_mask[tuple(outlier_coords.T)] = True
  164. valid_coords = tumor_coords[np.setdiff1d(np.arange(len(tumor_coords)), out_idx)]
  165. valid_values = volume[tuple(valid_coords.T)]
  166. filled = volume.copy()
  167. if valid_coords.shape[0] == 0:
  168. return filled, outlier_mask
  169. nn = NearestNeighbors(n_neighbors=min(k, len(valid_coords)), algorithm="kd_tree")
  170. nn.fit(valid_coords)
  171. _, neigh_idx = nn.kneighbors(outlier_coords)
  172. for i, idxs in enumerate(neigh_idx):
  173. filled[tuple(outlier_coords[i])] = float(np.mean(valid_values[idxs]))
  174. return filled.astype(np.float32, copy=False), outlier_mask
  176. def find_single_enclosed_empty_voxels(mask: np.ndarray) -> np.ndarray:
  177. mask = mask.astype(bool)
  178. empty = ~mask
  179. struct = generate_binary_structure(3, 1).astype(np.uint8)
  180. neigh = convolve(mask.astype(np.uint8), struct, mode="constant", cval=0)
  181. enclosed = empty & (neigh == 6)
  182. return enclosed
  184. def fill_enclosed_with_neighbor_mean(intensity_vol: np.ndarray, enclosed_mask: np.ndarray) -> np.ndarray:
  185. filled = intensity_vol.copy()
  186. Z, Y, X = intensity_vol.shape
  187. coords = np.argwhere(enclosed_mask)
  188. for z, y, x in coords:
  189. vals = []
  190. if z > 0: vals.append(intensity_vol[z-1, y, x ])
  191. if z < Z-1: vals.append(intensity_vol[z+1, y, x ])
  192. if y > 0: vals.append(intensity_vol[z, y-1, x ])
  193. if y < Y-1: vals.append(intensity_vol[z, y+1, x ])
  194. if x > 0: vals.append(intensity_vol[z, y, x-1])
  195. if x < X-1: vals.append(intensity_vol[z, y, x+1])
  196. if vals:
  197. filled[z, y, x] = float(np.mean(vals))
  198. return filled.astype(np.float32, copy=False)
  200. def rearrange_subcomponents_into_core(
  201. tumor_core_dict: dict[int, tuple[np.ndarray, np.ndarray]],
  202. tumor_core: np.ndarray,
  203. case_name: str,
  204. sample_idx: int,
  205. queue=None,
  206. rng: np.random.Generator = None,
  207. ) -> tuple[np.ndarray, np.ndarray]:
  208. tumor_core = tumor_core.astype(np.uint8, copy=False)
  209. core_vox = int(tumor_core.sum())
  210. if core_vox == 0:
  211. return np.zeros_like(tumor_core, dtype=np.uint8), np.zeros((4, *tumor_core.shape), dtype=np.float32)
  212. threshold = max(100, core_vox // 2)
  213. enh_islands, nonenh_islands, cyst_islands = [], [], []
  214. for label_key, (sub_mask, sub_mods) in tumor_core_dict.items():
  215. for i_idx, island in enumerate(extract_sorted_islands(sub_mask)):
  216. if island.sum() < 100:
  217. continue
  218. for j_idx, (cnt, split_island) in enumerate(split_large_island(island, threshold)):
  219. if cnt < 100:
  220. continue
  221. tup = (cnt,
  222. f"Comp{label_key}-Island{i_idx}-Split{j_idx}",
  223. split_island.astype(np.uint8, copy=False),
  224. label_key,
  225. sub_mods)
  226. if label_key == 1:
  227. enh_islands.append(tup)
  228. elif label_key == 2:
  229. nonenh_islands.append(tup)
  230. elif label_key == 3:
  231. cyst_islands.append(tup)
  232. enh_islands.sort(key=lambda x: x[0], reverse=True)
  233. nonenh_islands.sort(key=lambda x: x[0], reverse=True)
  234. cyst_islands.sort(key=lambda x: x[0], reverse=True)
  235. total_islands = len(enh_islands) + len(nonenh_islands) + len(cyst_islands)
  236. if queue is not None:
  237. queue.put(("progress", case_name, sample_idx, 0, total_islands))
  238. covered_core = np.zeros_like(tumor_core, dtype=np.uint8)
  239. placed = 0
  240. placed_ETs_vol = np.zeros((4, *tumor_core.shape), dtype=np.float32)
  241. placed_NETs_vol = np.zeros((4, *tumor_core.shape), dtype=np.float32)
  242. placed_CCs_vol = np.zeros((4, *tumor_core.shape), dtype=np.float32)
  243. placed_ETs_mask = np.zeros_like(tumor_core, dtype=np.uint8)
  244. placed_NETs_mask = np.zeros_like(tumor_core, dtype=np.uint8)
  245. placed_CCs_mask = np.zeros_like(tumor_core, dtype=np.uint8)
  246. components = [
  247. (1, enh_islands, "Enhancing"),
  248. (2, nonenh_islands, "Non-enhancing"),
  249. (3, cyst_islands, "Cystic"),
  250. ]
  251. while any(len(lst) > 0 for _, lst, _ in components):
  252. candidates = []
  253. for label_idx, lst, _ in components:
  254. if lst:
  255. cnt, island_id, island_mask, key_lbl, sub_mods = lst[0]
  256. candidates.append((cnt, island_mask, island_id, key_lbl, sub_mods, lst))
  257. candidates.sort(key=lambda t: t[0], reverse=True)
  258. for _, island_mask, island_id, key_lbl, sub_mods, source_list in candidates:
  259. params = optimize_island(island_mask, tumor_core, covered_core, rng=rng)
  260. t_mask, t_mods = transform_island(island_mask, params[:3], params[3:], modalities=sub_mods)
  261. placed += 1
  262. if queue is not None:
  263. queue.put(("island_placement", case_name, sample_idx, placed, total_islands))
  265. if t_mask.any():
  266. t_mask = gaussian_filter(t_mask.astype(np.float32), sigma=1.0) > 0.6
  267. t_mask = t_mask.astype(np.uint8, copy=False)
  268. if t_mods is not None:
  269. t_mods *= t_mask[None, ...]
  270. within_core = (t_mask > 0) & (tumor_core > 0)
  271. if within_core.any() and t_mods is not None:
  272. if key_lbl == 1:
  273. placed_ETs_vol[:, within_core] = t_mods[:, within_core]
  274. for m in range(4):
  275. placed_ETs_vol[m] = smooth_interface_with_kernel(
  276. placed_ETs_vol[m], t_mask.astype(bool), placed_ETs_mask.astype(bool),
  277. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3)
  278. )
  279. placed_ETs_mask[within_core] = 1
  280. elif key_lbl == 2:
  281. placed_NETs_vol[:, within_core] = t_mods[:, within_core]
  282. for m in range(4):
  283. placed_NETs_vol[m] = smooth_interface_with_kernel(
  284. placed_NETs_vol[m], t_mask.astype(bool), placed_NETs_mask.astype(bool),
  285. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3)
  286. )
  287. placed_NETs_mask[within_core] = 1
  288. elif key_lbl == 3:
  289. placed_CCs_vol[:, within_core] = t_mods[:, within_core]
  290. for m in range(4):
  291. placed_CCs_vol[m] = smooth_interface_with_kernel(
  292. placed_CCs_vol[m], t_mask.astype(bool), placed_CCs_mask.astype(bool),
  293. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3)
  294. )
  295. placed_CCs_mask[within_core] = 1
  296. covered_core[within_core] = 1
  297. source_list.pop(0)
  298. ET_holes = find_single_enclosed_empty_voxels(placed_ETs_mask)
  299. NET_holes = find_single_enclosed_empty_voxels(placed_NETs_mask)
  300. CC_holes = find_single_enclosed_empty_voxels(placed_CCs_mask)
  301. cleaned_ETs = np.zeros_like(placed_ETs_vol, dtype=np.float32)
  302. cleaned_NETs = np.zeros_like(placed_NETs_vol, dtype=np.float32)
  303. cleaned_CCs = np.zeros_like(placed_CCs_vol, dtype=np.float32)
  304. for m in range(4):
  305. if placed_ETs_mask.any():
  306. cleaned_ETs[m], _ = clean_mask_intensity_knn(placed_ETs_vol[m], placed_ETs_mask)
  307. cleaned_ETs[m] = fill_enclosed_with_neighbor_mean(cleaned_ETs[m], ET_holes)
  308. placed_ETs_mask[ET_holes] = 1
  309. if placed_NETs_mask.any():
  310. cleaned_NETs[m], _ = clean_mask_intensity_knn(placed_NETs_vol[m], placed_NETs_mask)
  311. cleaned_NETs[m] = fill_enclosed_with_neighbor_mean(cleaned_NETs[m], NET_holes)
  312. placed_NETs_mask[NET_holes] = 1
  313. if placed_CCs_mask.any():
  314. cleaned_CCs[m], _ = clean_mask_intensity_knn(placed_CCs_vol[m], placed_CCs_mask)
  315. cleaned_CCs[m] = fill_enclosed_with_neighbor_mean(cleaned_CCs[m], CC_holes)
  316. placed_CCs_mask[CC_holes] = 1
  317. final_vol = np.zeros_like(placed_ETs_vol, dtype=np.float32)
  318. final_mask = np.zeros_like(tumor_core, dtype=np.uint8)
  319. inter_mask = np.zeros_like(tumor_core, dtype=np.uint8)
  320. if placed_NETs_mask.any():
  321. final_vol[:, placed_NETs_mask > 0] = cleaned_NETs[:, placed_NETs_mask > 0]
  322. for m in range(4):
  323. final_vol[m] = smooth_interface_with_kernel(final_vol[m], placed_NETs_mask.astype(bool), inter_mask.astype(bool),
  324. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3))
  325. inter_mask[placed_NETs_mask > 0] = 1
  326. final_mask[placed_NETs_mask > 0] = 2
  327. if placed_CCs_mask.any():
  328. final_vol[:, placed_CCs_mask > 0] = cleaned_CCs[:, placed_CCs_mask > 0]
  329. for m in range(4):
  330. final_vol[m] = smooth_interface_with_kernel(final_vol[m], placed_CCs_mask.astype(bool), inter_mask.astype(bool),
  331. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3))
  332. inter_mask[placed_CCs_mask > 0] = 1
  333. final_mask[placed_CCs_mask > 0] = 3
  334. if placed_ETs_mask.any():
  335. final_vol[:, placed_ETs_mask > 0] = cleaned_ETs[:, placed_ETs_mask > 0]
  336. for m in range(4):
  337. final_vol[m] = smooth_interface_with_kernel(final_vol[m], placed_ETs_mask.astype(bool), inter_mask.astype(bool),
  338. dilate_iter=2, alpha=0.7, kernel_size=(3, 3, 3))
  339. inter_mask[placed_ETs_mask > 0] = 1
  340. final_mask[placed_ETs_mask > 0] = 1
  341. return final_mask, final_vol

rearrange.py at commit 6957bba, under MIT · at the source

Overview

Authors: Amin Tavallaii1,2,3, Shamim Shah Ghasi3
ORCID iDs: Amin Tavallaii
  1. Computational Neurosurgery Lab, Department of Neurosurgery, Macquarie University, Sydney, NSW, Australia
  2. Iranian Pediatric Neurosurgery Research Center, Tehran University of Medical Sciences, Tehran, Iran
  3. Department of Neurosurgery, Mashhad University of Medical Sciences, Mashhad, Iran
Institutions: Mashhad University of Medical Sciences (Iran); Tehran University of Medical Sciences (Iran); Macquarie University (Australia)
Journal: Frontiers in radiology, volume 6, article 1785108
Dates: received 11 January 2026; accepted 20 April 2026; published online 12 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fradi.2026.1785108 · PMID 42206199 · PMCID PMC13201455 · OpenAlex W7160948597
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), other condition (population), methods / tools (subfield)
Methods: Connectivity, Machine learning, Preprocessing, fMRI & imaging
Keywords: brain tumor, data augmentation, deep learning, multimodal MRI, segmentation
Topic: Advanced Neural Network Applications (Computer Vision and Pattern Recognition, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 17 references in the paper

Abstract

Background: Data scarcity and class imbalance remain critical challenges in medical image analysis, particularly for brain tumor MRI segmentation, where subcomponents such as enhancing tumor, non-enhancing tumor, cystic component, and peritumoral edema are underrepresented. Existing augmentation strategies, from classical geometric transforms to GAN-based and diffusion model-based synthesis, either lack subcomponent-level control or require extensive generative model training, limiting their practicality in low-data settings.

Materials and methods: We propose the Brain Tumor Compositional Augmentation Pipeline (BT-CAP), a subcomponent-aware and anatomically constrained augmentation framework for multi-modal MRI. BT-CAP decomposes tumor subcomponents and recomposes them through a sequence of targeted operations, including isotropic scaling, B-spline deformation, Powell-optimized spatial rearrangement, inpainting, interface smoothing, and constrained edema deformation, applied consistently across all MRI modalities and segmentation masks, producing label-ready augmented volumes without additional annotation. We evaluated augmentation diversity (SSIM, label distribution, intensity variation, centroid displacement) and anatomical plausibility on 50 BraTS-PEDs 2025 cases, yielding 250 augmented volumes, and assessed segmentation performance on the full 256-case dataset using 3-fold cross-validation.

Results: BT-CAP achieved a mean SSIM of 0.956 ± 0.014 with wide subcomponent volume change ranges and realistic intensity heterogeneity, confirming meaningful structural diversity. By architectural design, all augmented segmentation mask voxels were confined within brain boundaries, and zero overlap between deformed edema and the tumor core was observed across all 250 cases. Segmentation experiments showed mean Dice score improvements of 6%–7% for tumor subcomponents and 2%–3% for tumor core and whole tumor compared to training without compositional augmentation, with a computational cost of approximately 2 min per case on CPU.

Conclusion: BT-CAP establishes a new class of compositional augmentation methods that deliver anatomically structured, label-ready, and scalable data generation without generative model training. The framework is applicable to any multi-class segmentation task where data scarcity and structural fidelity are critical, and is openly available at https://github.com/dramintavallaii/BT-CAP.

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

dramintavallaii/BT-CAP

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 6957bba9ea25c8f588bca32eb18a60122e64252f, 5 September 2025
Languages: Python (11), Jupyter (2)
Size: 17 files, 13 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, environment (requirements.txt, setup.py), 2 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), SciPy (8 files), SimpleITK (5 files), scikit-image (2 files), scikit-learn (2 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
15 files
At the source: github.com/dramintavallaii/BT-CAP

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;
  • 13 scripts, each with its path and the digest of its content;
  • 16 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.

Data availability statement

All data, code, and implementations used in this study are openly available at the following GitHub repository: https://github.com/dramintavallaii/BT-CAP. Further inquiries can be directed to the corresponding author.

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

Recorded: type, language, journal, volume, pages, dates, 2 authors, 5 keywords, 8 references.

Cite

This paper

Tavallaii, A., & Shah Ghasi, S. (2026). BT-CAP: a subcomponent-aware and anatomically constrained data augmentation framework for multi-modal brain tumor MRI segmentation. Frontiers in radiology, 6, 1785108. https://doi.org/10.3389/fradi.2026.1785108

BibTeX

@article{tavallaii2026bt,
author = {Tavallaii, Amin and Shah Ghasi, Shamim},
title = {{BT-CAP: a subcomponent-aware and anatomically constrained data augmentation framework for multi-modal brain tumor MRI segmentation}},
journal = {Frontiers in radiology},
year = {2026},
month = may,
volume = {6},
pages = {1785108},
publisher = {Frontiers Media SA},
issn = {2673-8740},
doi = {10.3389/fradi.2026.1785108},
url = {https://doi.org/10.3389/fradi.2026.1785108},
pmid = {42206199},
pmcid = {PMC13201455}
}

RIS

TY - JOUR
AU - Tavallaii, Amin
AU - Shah Ghasi, Shamim
TI - BT-CAP: a subcomponent-aware and anatomically constrained data augmentation framework for multi-modal brain tumor MRI segmentation
T2 - Frontiers in radiology
J2 - Front Radiol
PY - 2026
DA - 2026/05/12
VL - 6
SP - 1785108
SN - 2673-8740
PB - Frontiers Media SA
DO - 10.3389/fradi.2026.1785108
UR - https://doi.org/10.3389/fradi.2026.1785108
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fradi.2026.1785108",
"type": "article-journal",
"title": "BT-CAP: a subcomponent-aware and anatomically constrained data augmentation framework for multi-modal brain tumor MRI segmentation",
"container-title": "Frontiers in radiology",
"author": [
{
"family": "Tavallaii",
"given": "Amin"
},
{
"family": "Shah Ghasi",
"given": "Shamim"
}
],
"container-title-short": "Front Radiol",
"volume": "6",
"page": "1785108",
"DOI": "10.3389/fradi.2026.1785108",
"PMID": "42206199",
"PMCID": "PMC13201455",
"ISSN": "2673-8740",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fradi.2026.1785108",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
12
]
]
}
}

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.3389/fmed.2026.1875760 [code]
Adaptive multi-stage domain unlearning for white-matter lesion segmentation.
Journal: Frontiers in medicine
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, 2 references
[2] doi:10.1002/hipo.70124 [code]
Association Between Anterior Hippocampal Gyrification and Episodic Memory Performance in Neurotypical Young Adults.
Journal: Hippocampus
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, structural MRI / diffusion, 2 references
[3] doi:10.1186/s12880-026-02335-x [code]
Automatic lateral ventricle and choroid plexus segmentation method in infant brain MR images.
Journal: BMC medical imaging
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, structural MRI / diffusion, 2 references
[4] doi:10.21037/qims-2026-0792 [code]
An nnU-Net-based framework with adaptive feature representation for 3D brain tumor segmentation.
Journal: Quantitative imaging in medicine and surgery
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, other condition, 1 reference
[5] doi:10.1038/s41598-026-48496-1 [code]
A unified FLAIR hyperintensity segmentation model for various CNS tumor types and acquisition time points.
Journal: Scientific reports
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, other condition, 1 reference
[6] doi:10.1038/s41598-026-55397-w [code]
Fast surface reconstruction of human brain MRI: benchmarking deep-learning based morphometry tools.
Journal: Scientific reports
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, 1 reference
[7] 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: SimpleITK, scikit-image, scikit-learn, 2 other tools, structural MRI / diffusion, other condition, 1 reference
[8] 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: SimpleITK, scikit-image, scikit-learn, 2 other tools, structural MRI / diffusion, 1 reference
[9] doi:10.3390/biomedicines14071475 [code]
ETDACVO: Structural-Fidelity-Aware Evolutionary Co-Optimization for Robust and Explainable Brain Tumor MRI Classification.
Journal: Biomedicines
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion, other condition
[10] doi:10.1016/j.adro.2026.102092 [code]
Effect of Anatomic Contextual Information on the Performance of a Convolutional Neural Network Tasked With Brain Metastasis Detection.
Journal: Advances in radiation oncology
In common: SimpleITK, scikit-image, scikit-learn, 2 other tools, other condition, 1 reference

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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