OSCR

See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion.

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 › Ablation experiment ↔ first_exp/Model/Model_NSCT_SpaFre.py, lines 143–276 · score 0.63 · high frequency components, NSCT decomposition, SPA, reconstructed, concatenated, MRI
  2. [2] § STAR★Methods › Method details › Frequency-guided fusion module ↔ first_exp/Model/CA_Block_Model.py, lines 21–50 · score 0.55 · feature map, channel attention, CA, height, width, module

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 · 352 lines · 14 KB · no license · 1 match

  1. import torch.nn as nn
  2. # import torch.nn.parallel
  3. import torch
  4. import torch.nn.functional as F
  5. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  6. import numpy as np
  7. # import matplotlib
  8. #
  9. # matplotlib.use('Agg')
  10. import matplotlib.pyplot as plt
  12. # torch_ver = torch.__version__[:3]
  13. from PPA import PPA_cu, PPA_xi
  14. from ReFusion import AFM
  15. from nsct_git import myNSCTd, myNSCTr
  16. import cv2
  17. from args import args
  20. class Low_Fusion(nn.Module):
  21. def __init__(self):
  22. super(Low_Fusion, self).__init__()
  24. def forward(self, low_freq1, low_freq2):
  25. # Average fusion for low-frequency components
  26. fused_d = (low_freq1 + low_freq2) / 2
  27. return fused_d
  28. # def load_image(path, gray=True):
  29. # """
  30. # 读取图像，默认转为灰度
  31. # """
  32. # if gray:
  33. # img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
  34. # else:
  35. # img = cv2.imread(path, cv2.IMREAD_COLOR)
  36. # if img is None:
  37. # raise FileNotFoundError(f"Cannot read image: {path}")
  38. # return img.astype(np.float32) / 255.0 # 归一化
  41. class High_Fusion(nn.Module):
  42. def __init__(self):
  43. super(High_Fusion, self).__init__()
  45. def forward(self, high_freq1, high_freq2):
  46. # Choose-max fusion for high-frequency components
  47. fused_h = np.maximum(np.abs(high_freq1), np.abs(high_freq2)) * np.sign(high_freq1 + high_freq2)
  48. return fused_h
  51. def mean_channels(F):
  52. assert (F.dim() == 4)
  53. spatial_sum = F.sum(3, keepdim=True).sum(2, keepdim=True)
  54. return spatial_sum / (F.size(2) * F.size(3))
  57. def stdv_channels(F):
  58. assert (F.dim() == 4)
  59. F_mean = mean_channels(F)
  60. F_variance = (F - F_mean).pow(2).sum(3, keepdim=True).sum(2, keepdim=True) / (F.size(2) * F.size(3))
  61. return F_variance.pow(0.5)
  64. class SpaFre(nn.Module):
  65. def __init__(self, channels):
  66. super(SpaFre, self).__init__()
  67. self.spa_att = nn.Sequential(nn.Conv2d(channels, channels // 2, kernel_size=3, padding=1, bias=True),
  68. nn.LeakyReLU(0.1),
  69. nn.Conv2d(channels // 2, channels, kernel_size=3, padding=1, bias=True),
  70. nn.Sigmoid())
  71. self.avgpool = nn.AdaptiveAvgPool2d(1)
  72. self.contrast = stdv_channels
  73. self.cha_att = nn.Sequential(nn.Conv2d(channels * 2, channels // 2, kernel_size=1, padding=0, bias=True),
  74. nn.LeakyReLU(0.1),
  75. nn.Conv2d(channels // 2, channels * 2, kernel_size=1, padding=0, bias=True),
  76. nn.Sigmoid())
  77. self.post = nn.Conv2d(channels * 2, channels, 3, 1, 1)
  79. def forward(self, spa_feat, freq_feat): # , i
  80. spa_map = self.spa_att(spa_feat - freq_feat)
  81. spa_res = freq_feat * spa_map + spa_feat
  82. cat_f = torch.cat([spa_res, freq_feat], 1)
  83. cha_res = self.post(self.cha_att(self.contrast(cat_f) + self.avgpool(cat_f)) * cat_f)
  85. return cha_res
  88. class Generator(nn.Module):
  89. def __init__(self):
  90. super(Generator, self).__init__()
  91. self.highfusion = High_Fusion()
  92. self.lowfusion = Low_Fusion()
  94. # 1. Initial feature extraction for 1-channel raw inputs to 16-channel features for AFM
  95. # Both PET and MRI are 1-channel grayscale images
  96. self.ir_initial_conv = nn.Sequential(
  97. nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
  98. nn.BatchNorm2d(16),
  99. nn.ReLU()
  100. )
  101. self.vi_initial_conv = nn.Sequential(
  102. nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
  103. nn.BatchNorm2d(16),
  104. nn.ReLU()
  105. )
  107. self.afm1 = AFM(16) # AFM takes 16-channel inputs, outputs dim*2 = 32 channels
  109. # 2. Conv layer to reduce AFM output channels from 32 to 16 for PPA_xi
  110. self.afm_output_conv = nn.Sequential(
  111. nn.Conv2d(32, 16, kernel_size=1, stride=1, padding=0), # 1x1 conv for channel reduction
  112. nn.BatchNorm2d(16),
  113. nn.ReLU()
  114. )
  116. self.PPA_xi = PPA_xi(16, 16) # PPA_xi expects 16 input channels and outputs 16 channels
  118. # 3. Conv layer to transform 1-channel NSCT reconstructed image to 16 channels for later concatenation
  119. self.nsct_freq_conv = nn.Sequential(
  120. nn.Conv2d(1, 16, kernel_size=1, stride=1, padding=0), # 保持1x1卷积核
  121. nn.BatchNorm2d(16),
  122. nn.ReLU()
  123. )
  125. # 4. Instantiate SpaFre with expected channel count (16), as its inputs will be 16 channels.
  126. # Its output (cha_res) will also be 'channels' (16) channels.
  127. self.spafre = SpaFre(16)
  129. # Final output conv layers for the Generator
  130. # These convs operate on the concatenated features (freq_features and spatial_features)
  131. # which will be 16 + 16 = 32 channels.
  132. self.final_conv1 = nn.Sequential(
  133. nn.Conv2d(32, 16, 3, 1, 1),
  134. nn.BatchNorm2d(16),
  135. nn.ReLU()
  136. )
  137. # 修改最终输出层，使用Sigmoid替代ReLU以保留更多细节
  138. self.final_conv2 = nn.Sequential(
  139. nn.Conv2d(16, 1, 3, 1, 1),
  140. nn.Sigmoid() # 使用Sigmoid而非ReLU，确保值域在[0,1]间，保留更多背景细节
  141. )
  143. def forward(self, ct, pet): ## ct is MRI, pet is CT from the original dataset pair
  145. # Convert raw 1-channel inputs to 16-channel features for spatial path
  146. ct_spa_features = self.ir_initial_conv(ct)
  147. pet_spa_features = self.vi_initial_conv(pet)
  149. # List to hold reconstructed frequency features for the batch
  150. reconstructed_freq_features_batch = []
  152. for i in range(ct.size(0)): # Iterate through the batch
  153. ct_num = ct[i, 0].cpu().numpy()
  154. pet_num = pet[i, 0].cpu().numpy()
  156. ################### NSCT decomposition, fusion, reconstruction begin ###############################
  157. [ct_Insp, ct_Insct] = myNSCTd(ct_num, levels=[3], pfiltername='pyr', dfiltername='pkva',
  158. type='NSCT')
  159. [pet_Insp, pet_Insct] = myNSCTd(pet_num, levels=[3], pfiltername='pyr', dfiltername='pkva',
  160. type='NSCT')
  162. ct_low = ct_Insct[0]
  164. ct_high_level1_1 = ct_Insct[1][0]
  165. ct_high_level1_2 = ct_Insct[1][1]
  166. ct_high_level1_3 = ct_Insct[1][2]
  167. ct_high_level1_4 = ct_Insct[1][3]
  168. ct_high_level1_5 = ct_Insct[1][4]
  169. ct_high_level1_6 = ct_Insct[1][5]
  170. ct_high_level1_7 = ct_Insct[1][6]
  171. ct_high_level1_8 = ct_Insct[1][7]
  173. # ct_high_level2_1 = ct_Insct[2][0]
  174. # ct_high_level2_2 = ct_Insct[2][1]
  175. # ct_high_level2_3 = ct_Insct[2][2]
  176. # ct_high_level2_4 = ct_Insct[2][3]
  177. # ct_high_level2_5 = ct_Insct[2][4]
  178. # ct_high_level2_6 = ct_Insct[2][5]
  179. # ct_high_level2_7 = ct_Insct[2][6]
  180. # ct_high_level2_8 = ct_Insct[2][7]
  182. pet_low = pet_Insct[0]
  184. pet_high_level1_1 = pet_Insct[1][0]
  185. pet_high_level1_2 = pet_Insct[1][1]
  186. pet_high_level1_3 = pet_Insct[1][2]
  187. pet_high_level1_4 = pet_Insct[1][3]
  188. pet_high_level1_5 = pet_Insct[1][4]
  189. pet_high_level1_6 = pet_Insct[1][5]
  190. pet_high_level1_7 = pet_Insct[1][6]
  191. pet_high_level1_8 = pet_Insct[1][7]
  193. # pet_high_level2_1 = pet_Insct[2][0]
  194. # pet_high_level2_2 = pet_Insct[2][1]
  195. # pet_high_level2_3 = pet_Insct[2][2]
  196. # pet_high_level2_4 = pet_Insct[2][3]
  197. # pet_high_level2_5 = pet_Insct[2][4]
  198. # pet_high_level2_6 = pet_Insct[2][5]
  199. # pet_high_level2_7 = pet_Insct[2][6]
  200. # pet_high_level2_8 = pet_Insct[2][7]
  202. # Low-frequency fusion
  203. fusion_low_nsct = self.lowfusion(ct_low, pet_low)
  205. fusion_high_level1_1_nsct = self.highfusion(ct_high_level1_1, pet_high_level1_1)
  206. fusion_high_level1_2_nsct = self.highfusion(ct_high_level1_2, pet_high_level1_2)
  207. fusion_high_level1_3_nsct = self.highfusion(ct_high_level1_3, pet_high_level1_3)
  208. fusion_high_level1_4_nsct = self.highfusion(ct_high_level1_4, pet_high_level1_4)
  209. fusion_high_level1_5_nsct = self.highfusion(ct_high_level1_5, pet_high_level1_5)
  210. fusion_high_level1_6_nsct = self.highfusion(ct_high_level1_6, pet_high_level1_6)
  211. fusion_high_level1_7_nsct = self.highfusion(ct_high_level1_7, pet_high_level1_7)
  212. fusion_high_level1_8_nsct = self.highfusion(ct_high_level1_8, pet_high_level1_8)
  214. # fusion_high_level2_1_nsct = self.highfusion(ct_high_level2_1, pet_high_level2_1)
  215. # fusion_high_level2_2_nsct = self.highfusion(ct_high_level2_2, pet_high_level2_2)
  216. # fusion_high_level2_3_nsct = self.highfusion(ct_high_level2_3, pet_high_level2_3)
  217. # fusion_high_level2_4_nsct = self.highfusion(ct_high_level2_4, pet_high_level2_4)
  218. # fusion_high_level2_5_nsct = self.highfusion(ct_high_level2_5, pet_high_level2_5)
  219. # fusion_high_level2_6_nsct = self.highfusion(ct_high_level2_6, pet_high_level2_6)
  220. # fusion_high_level2_7_nsct = self.highfusion(ct_high_level2_7, pet_high_level2_7)
  221. # fusion_high_level2_8_nsct = self.highfusion(ct_high_level2_8, pet_high_level2_8)
  223. Insct_re = []
  224. Insct_re.append(fusion_low_nsct)
  226. # High-frequency components level 1 (8 directions)
  227. level1 = [fusion_high_level1_1_nsct, fusion_high_level1_2_nsct, fusion_high_level1_3_nsct,
  228. fusion_high_level1_4_nsct,
  229. fusion_high_level1_5_nsct, fusion_high_level1_6_nsct, fusion_high_level1_7_nsct,
  230. fusion_high_level1_8_nsct]
  231. Insct_re.append(level1)
  233. # High-frequency components level 2 (8 directions)
  234. # level2 = [fusion_high_level2_1_nsct, fusion_high_level2_2_nsct, fusion_high_level2_3_nsct,
  235. # fusion_high_level2_4_nsct,
  236. # fusion_high_level2_5_nsct, fusion_high_level2_6_nsct, fusion_high_level2_7_nsct,
  237. # fusion_high_level2_8_nsct]
  238. # Insct_re.append(level2)
  240. # Reconstruct NSCT image (numpy and 1-channel)
  241. reconstructed_img_np_single = myNSCTr(Insct_re, levels=[3], pfiltername='pyr', dfiltername='pkva',
  242. type='NSCT')
  244. # Convert numpy to tensor and add batch dimension (B, C, H, W) for single image
  245. if len(reconstructed_img_np_single.shape) == 2: # (H, W)
  246. reconstructed_img_tensor_single = torch.from_numpy(reconstructed_img_np_single).float().unsqueeze(
  247. 0).unsqueeze(0) # -> (1, 1, H, W)
  248. else: # Assuming (C, H, W) already, then just add batch dim -> (1, C, H, W)
  249. reconstructed_img_tensor_single = torch.from_numpy(reconstructed_img_np_single).float().unsqueeze(0)
  251. # Ensure reconstructed_img_tensor_single is on the same device as inputs
  252. reconstructed_img_tensor_single = reconstructed_img_tensor_single.to(ct.device)
  253. reconstructed_freq_features_batch.append(reconstructed_img_tensor_single)
  255. # Stack the list into a single batch tensor
  256. reconstructed_freq_features = torch.cat(reconstructed_freq_features_batch, dim=0)
  258. # Merge AFM and PPA features from spatial path
  259. merged_spa_features = self.afm1(ct_spa_features, pet_spa_features)
  260. merged_spa_features = self.afm_output_conv(merged_spa_features)
  261. ppa_spa_features = self.PPA_xi(merged_spa_features)
  263. # Process NSCT reconstructed image through conv to get freq features
  264. freq_features = self.nsct_freq_conv(reconstructed_freq_features)
  266. # Apply SpaFre on both spatial and frequency paths
  267. spafreq_features = self.spafre(ppa_spa_features, freq_features)
  269. # Concatenate the features from all branches
  270. concat_features = torch.cat([spafreq_features, freq_features], dim=1)
  272. # Final processing
  273. out = self.final_conv1(concat_features)
  274. out = self.final_conv2(out)
  276. return out
  279. def tensor_to_numpy_recursive(obj):
  280. if isinstance(obj, list):
  281. return [tensor_to_numpy_recursive(item) for item in obj]
  282. elif hasattr(obj, 'detach'):
  283. return obj.detach().cpu().numpy()
  284. else:
  285. return obj
  288. class D_IR(nn.Module):
  289. def __init__(self):
  290. super(D_IR, self).__init__()
  291. fliter = [1, 16, 32, 64, 128]
  292. kernel_size = 3
  293. stride = 2
  294. self.l1 = ConvLayer_dis(fliter[0], fliter[1], kernel_size, stride, use_Leakyrelu=True)
  295. self.l2 = ConvLayer_dis(fliter[1], fliter[2], kernel_size, stride, use_Leakyrelu=True)
  296. self.l3 = ConvLayer_dis(fliter[2], fliter[3], kernel_size, stride, use_Leakyrelu=True)
  297. self.l4 = ConvLayer_dis(fliter[3], fliter[4], kernel_size, stride, use_Leakyrelu=False)
  298. self.tanh = nn.Tanh()
  300. def forward(self, x):
  301. out = self.l1(x)
  302. out = self.l2(out)
  303. out = self.l3(out)
  304. out = self.l4(out)
  305. out = self.tanh(out)
  307. return out
  310. class D_VI(nn.Module):
  311. def __init__(self):
  312. super(D_VI, self).__init__()
  313. fliter = [1, 16, 32, 64, 128]
  314. kernel_size = 3
  315. stride = 2
  316. self.l1 = ConvLayer_dis(fliter[0], fliter[1], kernel_size, stride, use_Leakyrelu=True)
  317. self.l2 = ConvLayer_dis(fliter[1], fliter[2], kernel_size, stride, use_Leakyrelu=True)
  318. self.l3 = ConvLayer_dis(fliter[2], fliter[3], kernel_size, stride, use_Leakyrelu=True)
  319. self.l4 = ConvLayer_dis(fliter[3], fliter[4], kernel_size, stride, use_Leakyrelu=False)
  320. self.tanh = nn.Tanh()
  322. def forward(self, x):
  323. out = self.l1(x)
  324. out = self.l2(out)
  325. out = self.l3(out)
  326. out = self.l4(out)
  327. out = self.tanh(out)
  329. return out
  332. class ConvLayer_dis(torch.nn.Module):
  333. def __init__(self, in_channels, out_channels, kernel_size, stride, use_Leakyrelu=True):
  334. super(ConvLayer_dis, self).__init__()
  336. self.conv2d = nn.Conv2d(in_channels, out_channels, kernel_size, stride)
  337. self.use_Leakyrelu = use_Leakyrelu
  338. self.LeakyReLU = nn.LeakyReLU(0.2)
  340. def forward(self, x):
  341. out = self.conv2d(x)
  342. if self.use_Leakyrelu is True:
  343. out = self.LeakyReLU(out)
  344. return out
  347. if __name__ == '__main__':
  348. a = torch.rand(1, 1, 356, 356).cuda()
  349. b = torch.rand(1, 1, 356, 356).cuda()
  350. m = Generator().cuda()
  351. out = m(a, b)
  352. print(out.size())

Model_NSCT_SpaFre.py at commit 1366b60, no license · at the source

Overview

Authors: Tao Zhou1,2, Jiaqi Wang1,2, Huiling Lu3, Mingzhe Zhang1,2, Zhe Zhang1,2, Hongqiang Yu1,2, Pengfei Zheng4
ORCID iDs: Jiaqi Wang
  1. School of Computer Science and Engineering, North Minzu University, Yinchuan 750021, China
  2. Key Laboratory of Image and Graphics Intelligent Processing of State Ethnic Affairs Commission, North Minzu University, Yinchuan 750021, China
  3. School of Medical Information and Engineering, Ningxia Medical University, Yinchuan 750004, China
  4. Tandon School of Engineering, New York University, New York, NY 11021, USA
Institutions: State Ethnic Affairs Commission (China); North Minzu University (China); Ningxia Medical University (China); New York University (United States)
Journal: iScience, volume 29, issue 6, article 116168
Dates: received 11 January 2026; accepted 13 May 2026; published online 9 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.isci.2026.116168 · PMID 42317736 · PMCID PMC13273592 · OpenAlex W7164008726
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: methods / tools (subfield)
Methods: Spectral & time-frequency, Machine learning, Connectivity
Keywords: Biocomputational method, Medical imaging
Topic: Advanced Image Fusion Techniques (Media Technology, Engineering), according to OpenAlex
Funding: Ningxia Hui Autonomous Region Natural Science Foundation (2025AAC020006); National Natural Science Foundation of China (62576009, 62561002)
Citations: not cited yet (Europe PMC); 29 references in the paper

Abstract

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

Repositories

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

wjq-111/FGSD_GAN

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 1366b608dd028400bdedd5c7c012c2eb46fb5b92, 4 March 2026
Languages: Python (23)
Size: 169 files, 23 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, environment (first_exp/setup.py)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (20 files), NumPy (12 files), Matplotlib (8 files), OpenCV (7 files), SciPy (5 files), Pillow (3 files), scikit-image (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
23 files
At the source: github.com/wjq-111/FGSD_GAN.git

hanna-xu/MURF

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 79b270af4ec8a77a7ed880ec6890a5cf9fe3f268, 9 April 2024
Languages: Python (65)
Size: 181 files, 65 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (65 files), TensorFlow (65 files), Matplotlib (51 files), SciPy (51 files), h5py (27 files), scikit-image (24 files), OpenCV (19 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
66 files
At the source: github.com/hanna-xu/MURF

Zhaozixiang1228/MMIF-EMMA

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9983ca2f627588cd001ed08e21eadf1ab5c48beb, 8 June 2026
Languages: Python (8)
Size: 25 files, 8 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (6 files), NumPy (5 files), h5py (3 files), scikit-image (2 files), OpenCV (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
9 files
At the source: github.com/Zhaozixiang1228/MMIF-EMMA

tthinking/DATFuse

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0cd93f15fb5552c7aef79b7be56726c863d6c5ba, 8 September 2024
Languages: Python (4), MATLAB (1)
Size: 21 files, 5 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (4 files), Pillow (2 files), imageio (1 file), Image Processing Toolbox (1 file), NumPy (1 file), pandas (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/tthinking/DATFuse

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:

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

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

  • it points to the authors' code: wjq-111/FGSD_GAN
  • it says that the data are available on request

Read it in the paper: doi.org/10.1016/j.isci.2026.116168.

Versions

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

Version 2, 28 September 2026

  • Authors: added Jiaqi Wang (0009-0003-1028-6655); removed Jiaqi Wang

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 2 keywords, 2 funders, 28 references.

Cite

This paper

Zhou, T., Wang, J., Lu, H., Zhang, M., Zhang, Z., Yu, H., & Zheng, P. (2026). See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion. iScience, 29(6), 116168. https://doi.org/10.1016/j.isci.2026.116168

BibTeX

@article{zhou2026see,
author = {Zhou, Tao and Wang, Jiaqi and Lu, Huiling and Zhang, Mingzhe and Zhang, Zhe and Yu, Hongqiang and Zheng, Pengfei},
title = {{See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion}},
journal = {iScience},
year = {2026},
month = jun,
volume = {29},
number = {6},
pages = {116168},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.116168},
url = {https://doi.org/10.1016/j.isci.2026.116168},
pmid = {42317736},
pmcid = {PMC13273592}
}

RIS

TY - JOUR
AU - Zhou, Tao
AU - Wang, Jiaqi
AU - Lu, Huiling
AU - Zhang, Mingzhe
AU - Zhang, Zhe
AU - Yu, Hongqiang
AU - Zheng, Pengfei
TI - See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/06/09
VL - 29
IS - 6
SP - 116168
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.116168
UR - https://doi.org/10.1016/j.isci.2026.116168
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.116168",
"type": "article-journal",
"title": "See the small lesions: Frequency-guided spatial debiasing GAN for multimodal medical image fusion",
"container-title": "iScience",
"author": [
{
"family": "Zhou",
"given": "Tao"
},
{
"family": "Wang",
"given": "Jiaqi"
},
{
"family": "Lu",
"given": "Huiling"
},
{
"family": "Zhang",
"given": "Mingzhe"
},
{
"family": "Zhang",
"given": "Zhe"
},
{
"family": "Yu",
"given": "Hongqiang"
},
{
"family": "Zheng",
"given": "Pengfei"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "6",
"page": "116168",
"DOI": "10.1016/j.isci.2026.116168",
"PMID": "42317736",
"PMCID": "PMC13273592",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.116168",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
9
]
]
}
}

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.1364/boe.605322 [code]
Generalized plaque digitization framework for multi-dimensional mesoscopic images.
Journal: Biomedical optics express
In common: imageio, TensorFlow, OpenCV, 9 other tools
[2] doi:10.1371/journal.pcbi.1014263 [code]
MIRAGE: Robust multi-modal architectures translate fMRI-to-image models from vision to mental imagery.
Journal: PLoS computational biology
In common: imageio, OpenCV, scikit-image, 8 other tools, 1 reference
[3] 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, 8 other tools, methods / tools
[4] 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, 8 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, 8 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, 8 other tools, methods / tools
[7] doi: [code]
Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: imageio, TensorFlow, OpenCV, 8 other tools
[8] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: imageio, TensorFlow, OpenCV, 8 other tools
[9] doi:10.1002/epi.70296 [code]
Fully automated three-dimensional deep learning-based magnetic resonance imaging segmentation of brain cavities in epilepsy surgery.
Journal: Epilepsia
In common: imageio, TensorFlow, OpenCV, 8 other tools
[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, TensorFlow, OpenCV, 8 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.