OSCR

DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI.

Code ↔ Paper

13 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 13 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Methods › DDSurfer Network › Subnetwork: DualStream–FuseNet ↔ net/ddsurfer_tanet_dualstream_cascaded.py, lines 45–126 · score 0.73 · Cross Stream, Fusion module, bottleneck, encoders, gating, LKA
  2. [2] § Methods › DDSurfer Network › Subnetwork: DualStream–FuseNet ↔ net/ddsurfer_tanet_dualstream_cascaded.py, lines 45–126 · score 0.71 · cross stream fusion, fusion module, upsampled, encoder, decoder, stem
  3. [3] § Methods › Implementation Details and SlicerDDSurfer ↔ ddsurfer_predict_lh_dualstream.py, lines 86–184 · score 0.70 · template mesh, pial surface model, WM surface, PyTorch, predict, volume
  4. [4] § Methods › Implementation Details and SlicerDDSurfer ↔ ddsurfer_predict_rh_dualstream.py, lines 80–182 · score 0.70 · template mesh, pial surface model, WM surface, PyTorch, predict, volume
  5. [5] § Methods › DDSurfer Network › Subnetwork: DualStream–FuseNet ↔ model/CMUNeXt_3D.py, lines 1–31 · score 0.65 · CMUNeXt, dual stream, lightweight, convolution, block, fusion
  6. [6] § Methods › Implementation Details and SlicerDDSurfer ↔ utils/space_MNI2orig.sh, lines 1–25 · score 0.60 · native space, post processing, cortical surface, workflow, MNI, DDSurfer
  7. [7] § Experimental Section › Datasets and Preprocessing › DMRI Preprocessing and DTI Parameter Computation ↔ pnlpipe_pipelines/epi.py, the whole file · a weak match · score 0.59 · EPI distortion correction, eddy, rigid, masking, pipeline, brain
  8. [8] § Experimental Section › Ablation Studies ↔ net/ddsurfer_tanet_dualstream_cascaded.py, lines 14–38 · score 0.59 · Fusion Module, dual stream, block, Kernel, Cross, channel
  9. [9] § Methods ↔ utils/space_MNI2orig.sh, lines 1–25 · score 0.56 · automated pipeline, post processing, cortical surface, workflow, deformations, DDSurfer
  10. [10] § Methods › Implementation Details and SlicerDDSurfer ↔ run_ddsurfer_pipeline.py, lines 1–18 · score 0.55 · native space, post processing, interface, DDSurfer, preprocessing, predicted
  11. [11] § Methods › DDSurfer Network › Loss Function Design ↔ ddsurfer_predict_lh_dualstream.py, lines 86–184 · score 0.55 · predicted WM surface, pial surface model, location, vertices, error
  12. [12] § Methods › DDSurfer Network › Loss Function Design ↔ ddsurfer_predict_rh_dualstream.py, lines 80–182 · score 0.55 · predicted WM surface, pial surface model, location, vertices, error
  13. [13] § Methods › DDSurfer Network › Subnetwork: DiffeoSurf–FlowNet ↔ net/ddsurfer_tanet_dualstream_cascaded.py, lines 201–218 · score 0.50 · stationary velocity fields, weighted, predicted

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 · 311 lines · 15 KB · no license · 4 matches

  1. """TANet dual-stream architecture using CMUNeXt backbones and large-kernel attention."""
  3. from __future__ import annotations
  5. from typing import Sequence
  7. import torch
  8. import torch.nn as nn
  9. import torch.nn.functional as F
  11. from model.CMUNeXt_3D import AttentionGate3D, CMUNeXtBlock3D_SE, conv_block_3d, fusion_conv_3d, up_conv_3d
  12. from model.D_LKA_Attention import LKA_Attention3d
  14. # ------------------------- Building Blocks -------------------------
  15. class CrossAttentionFusionModule(nn.Module):
  16. """Bidirectional channel attention to fuse dual streams."""
  18. def __init__(self, channels_a: int, channels_b: int, reduction: int = 4) -> None:
  19. super().__init__()
  20. inter_channels_a = max(1, channels_a // reduction)
  21. inter_channels_b = max(1, channels_b // reduction)
  22. self.gate_generator_A = nn.Sequential(
  23. nn.Conv3d(channels_b, inter_channels_a, kernel_size=1),
  24. nn.ReLU(inplace=True),
  25. nn.Conv3d(inter_channels_a, channels_a, kernel_size=1),
  26. nn.Sigmoid(),
  27. )
  28. self.gate_generator_B = nn.Sequential(
  29. nn.Conv3d(channels_a, inter_channels_b, kernel_size=1),
  30. nn.ReLU(inplace=True),
  31. nn.Conv3d(inter_channels_b, channels_b, kernel_size=1),
  32. nn.Sigmoid(),
  33. )
  35. def forward(self, features_a: torch.Tensor, features_b: torch.Tensor) -> torch.Tensor:
  36. refined_a = features_a * self.gate_generator_A(features_b)
  37. refined_b = features_b * self.gate_generator_B(features_a)
  38. return torch.cat((refined_a, refined_b), dim=1)
  41. # ------------------------- Velocity Field Backbone -------------------------
  42. class CMUNeXt_VFNet_Final(nn.Module):
  43. """Dual-stream CMUNeXt encoder-decoder that predicts cascaded velocity fields."""
  45. def __init__(
  46. self,
  47. input_channel: int = 5,
  48. dims: list[int] | tuple[int, ...] = (16, 32, 64, 128, 256),
  49. depths: list[int] | tuple[int, ...] = (1, 1, 1, 6, 3),
  50. kernels: list[int] | tuple[int, ...] = (3, 3, 7, 7, 7),
  51. M: int = 2,
  52. R: int = 3,
  53. kernel_size: int = 3,
  54. ) -> None:
  55. super().__init__()
  56. self.M, self.R = int(M), int(R)
  58. self.dims_A = [int(d * 0.4) for d in dims]
  59. self.dims_B = [d - a for d, a in zip(dims, self.dims_A)]
  61. # Encoder streams
  62. self.stem_A = conv_block_3d(1, self.dims_A[0])
  63. self.encoder1_A = CMUNeXtBlock3D_SE(self.dims_A[0], self.dims_A[0], depth=depths[0], kernel_size=kernels[0])
  64. self.encoder2_A = CMUNeXtBlock3D_SE(self.dims_A[0], self.dims_A[1], depth=depths[1], kernel_size=kernels[1])
  65. self.encoder3_A = CMUNeXtBlock3D_SE(self.dims_A[1], self.dims_A[2], depth=depths[2], kernel_size=kernels[2])
  66. self.encoder4_A = CMUNeXtBlock3D_SE(self.dims_A[2], self.dims_A[3], depth=depths[3], kernel_size=kernels[3])
  67. self.encoder5_A = CMUNeXtBlock3D_SE(self.dims_A[3], self.dims_A[4], depth=depths[4], kernel_size=kernels[4])
  69. self.stem_B = conv_block_3d(input_channel - 1, self.dims_B[0])
  70. self.encoder1_B = CMUNeXtBlock3D_SE(self.dims_B[0], self.dims_B[0], depth=depths[0], kernel_size=kernels[0])
  71. self.encoder2_B = CMUNeXtBlock3D_SE(self.dims_B[0], self.dims_B[1], depth=depths[1], kernel_size=kernels[1])
  72. self.encoder3_B = CMUNeXtBlock3D_SE(self.dims_B[1], self.dims_B[2], depth=depths[2], kernel_size=kernels[2])
  73. self.encoder4_B = CMUNeXtBlock3D_SE(self.dims_B[2], self.dims_B[3], depth=depths[3], kernel_size=kernels[3])
  74. self.encoder5_B = CMUNeXtBlock3D_SE(self.dims_B[3], self.dims_B[4], depth=depths[4], kernel_size=kernels[4])
  76. # Cross-stream fusion and bottleneck
  77. self.fusion1 = CrossAttentionFusionModule(self.dims_A[0], self.dims_B[0])
  78. self.fusion2 = CrossAttentionFusionModule(self.dims_A[1], self.dims_B[1])
  79. self.fusion3 = CrossAttentionFusionModule(self.dims_A[2], self.dims_B[2])
  80. self.fusion4 = CrossAttentionFusionModule(self.dims_A[3], self.dims_B[3])
  81. self.fusion5 = CrossAttentionFusionModule(self.dims_A[4], self.dims_B[4])
  83. self.Maxpool = nn.MaxPool3d(kernel_size=2, stride=2)
  84. self.lka_attention = LKA_Attention3d(d_model=dims[4])
  86. # Decoder with attention gates
  87. self.Up5_A = up_conv_3d(self.dims_A[4], self.dims_A[3])
  88. self.Up5_B = up_conv_3d(self.dims_B[4], self.dims_B[3])
  89. self.Att5_A = AttentionGate3D(self.dims_A[3], self.dims_A[3], self.dims_A[2])
  90. self.Att5_B = AttentionGate3D(self.dims_B[3], self.dims_B[3], self.dims_B[2])
  91. self.Up_conv5_A = fusion_conv_3d(self.dims_A[3] * 2, self.dims_A[3])
  92. self.Up_conv5_B = fusion_conv_3d(self.dims_B[3] * 2, self.dims_B[3])
  93. self.decoder_fusion4 = CrossAttentionFusionModule(self.dims_A[3], self.dims_B[3])
  95. self.Up4_A = up_conv_3d(self.dims_A[3], self.dims_A[2])
  96. self.Up4_B = up_conv_3d(self.dims_B[3], self.dims_B[2])
  97. self.Att4_A = AttentionGate3D(self.dims_A[2], self.dims_A[2], self.dims_A[1])
  98. self.Att4_B = AttentionGate3D(self.dims_B[2], self.dims_B[2], self.dims_B[1])
  99. self.Up_conv4_A = fusion_conv_3d(self.dims_A[2] * 2, self.dims_A[2])
  100. self.Up_conv4_B = fusion_conv_3d(self.dims_B[2] * 2, self.dims_B[2])
  101. self.decoder_fusion3 = CrossAttentionFusionModule(self.dims_A[2], self.dims_B[2])
  103. self.Up3_A = up_conv_3d(self.dims_A[2], self.dims_A[1])
  104. self.Up3_B = up_conv_3d(self.dims_B[2], self.dims_B[1])
  105. self.Att3_A = AttentionGate3D(self.dims_A[1], self.dims_A[1], self.dims_A[0])
  106. self.Att3_B = AttentionGate3D(self.dims_B[1], self.dims_B[1], self.dims_B[0])
  107. self.Up_conv3_A = fusion_conv_3d(self.dims_A[1] * 2, self.dims_A[1])
  108. self.Up_conv3_B = fusion_conv_3d(self.dims_B[1] * 2, self.dims_B[1])
  109. self.decoder_fusion2 = CrossAttentionFusionModule(self.dims_A[1], self.dims_B[1])
  111. self.Up2_A = up_conv_3d(self.dims_A[1], self.dims_A[0])
  112. self.Up2_B = up_conv_3d(self.dims_B[1], self.dims_B[0])
  113. self.Att2_A = AttentionGate3D(self.dims_A[0], self.dims_A[0], self.dims_A[0] // 2)
  114. self.Att2_B = AttentionGate3D(self.dims_B[0], self.dims_B[0], self.dims_B[0] // 2)
  115. self.Up_conv2_A = fusion_conv_3d(self.dims_A[0] * 2, self.dims_A[0])
  116. self.Up_conv2_B = fusion_conv_3d(self.dims_B[0] * 2, self.dims_B[0])
  118. # Cascaded velocity heads
  119. self.flow1 = nn.Conv3d(dims[2], 3 * M, kernel_size=kernel_size, padding=kernel_size // 2)
  120. self.flow2 = nn.Conv3d(dims[1] + 3 * M, 3 * M, kernel_size=kernel_size, padding=kernel_size // 2)
  121. self.flow3 = nn.Conv3d(dims[0] + 3 * M, 3 * M, kernel_size=kernel_size, padding=kernel_size // 2)
  122. for conv in (self.flow1, self.flow2, self.flow3):
  123. nn.init.normal_(conv.weight, 0.0, 1e-5)
  124. nn.init.constant_(conv.bias, 0.0)
  126. self.up = nn.Upsample(scale_factor=2, mode="trilinear", align_corners=True)
  128. def forward(self, x: torch.Tensor) -> torch.Tensor:
  129. stream_a = x[:, 0:1]
  130. stream_b = x[:, 1:]
  132. x1_a = self.encoder1_A(self.stem_A(stream_a))
  133. x1_b = self.encoder1_B(self.stem_B(stream_b))
  134. x2_a = self.encoder2_A(self.Maxpool(x1_a))
  135. x2_b = self.encoder2_B(self.Maxpool(x1_b))
  136. x3_a = self.encoder3_A(self.Maxpool(x2_a))
  137. x3_b = self.encoder3_B(self.Maxpool(x2_b))
  138. x4_a = self.encoder4_A(self.Maxpool(x3_a))
  139. x4_b = self.encoder4_B(self.Maxpool(x3_b))
  140. x5_a = self.encoder5_A(self.Maxpool(x4_a))
  141. x5_b = self.encoder5_B(self.Maxpool(x4_b))
  143. bottleneck = self.lka_attention(self.fusion5(x5_a, x5_b))
  144. d5_a_in, d5_b_in = torch.split(bottleneck, [self.dims_A[4], self.dims_B[4]], dim=1)
  146. d5_a = self.Up5_A(d5_a_in)
  147. d5_b = self.Up5_B(d5_b_in)
  148. x4_a_att = self.Att5_A(d5_a, x4_a)
  149. x4_b_att = self.Att5_B(d5_b, x4_b)
  150. d4_a = self.Up_conv5_A(torch.cat([x4_a_att, d5_a], dim=1))
  151. d4_b = self.Up_conv5_B(torch.cat([x4_b_att, d5_b], dim=1))
  152. d4_fused = self.decoder_fusion4(d4_a, d4_b)
  153. d4_a_out, d4_b_out = torch.split(d4_fused, [self.dims_A[3], self.dims_B[3]], dim=1)
  155. d4_a_up = self.Up4_A(d4_a_out)
  156. d4_b_up = self.Up4_B(d4_b_out)
  157. x3_a_att = self.Att4_A(d4_a_up, x3_a)
  158. x3_b_att = self.Att4_B(d4_b_up, x3_b)
  159. d3_a = self.Up_conv4_A(torch.cat([x3_a_att, d4_a_up], dim=1))
  160. d3_b = self.Up_conv4_B(torch.cat([x3_b_att, d4_b_up], dim=1))
  161. d3_fused = self.decoder_fusion3(d3_a, d3_b)
  162. vf1_small = self.flow1(d3_fused)
  164. d3_a_out, d3_b_out = torch.split(d3_fused, [self.dims_A[2], self.dims_B[2]], dim=1)
  165. d3_a_up = self.Up3_A(d3_a_out)
  166. d3_b_up = self.Up3_B(d3_b_out)
  167. x2_a_att = self.Att3_A(d3_a_up, x2_a)
  168. x2_b_att = self.Att3_B(d3_b_up, x2_b)
  169. d2_a = self.Up_conv3_A(torch.cat([x2_a_att, d3_a_up], dim=1))
  170. d2_b = self.Up_conv3_B(torch.cat([x2_b_att, d3_b_up], dim=1))
  171. d2_fused = self.decoder_fusion2(d2_a, d2_b)
  173. vf1_medium = self.up(vf1_small)
  174. vf2_medium = vf1_medium + self.flow2(torch.cat([d2_fused, vf1_medium], dim=1))
  176. d2_a_out, d2_b_out = torch.split(d2_fused, [self.dims_A[1], self.dims_B[1]], dim=1)
  177. d2_a_up = self.Up2_A(d2_a_out)
  178. d2_b_up = self.Up2_B(d2_b_out)
  179. x1_a_att = self.Att2_A(d2_a_up, x1_a)
  180. x1_b_att = self.Att2_B(d2_b_up, x1_b)
  181. d1_a = self.Up_conv2_A(torch.cat([x1_a_att, d2_a_up], dim=1))
  182. d1_b = self.Up_conv2_B(torch.cat([x1_b_att, d2_b_up], dim=1))
  183. d1_fused = torch.cat([d1_a, d1_b], dim=1)
  185. vf2_full = self.up(vf2_medium)
  186. vf3_full = vf2_full + self.flow3(torch.cat([d1_fused, vf2_full], dim=1))
  187. vf1_full = self.up(vf1_medium)
  189. vf1 = vf1_full.reshape(self.M, 3, *vf1_full.shape[2:])
  190. vf2 = vf2_full.reshape(self.M, 3, *vf2_full.shape[2:])
  191. vf3 = vf3_full.reshape(self.M, 3, *vf3_full.shape[2:])
  193. if self.R == 3:
  194. return torch.cat([vf1, vf2, vf3], dim=0)
  195. if self.R == 2:
  196. return torch.cat([vf2, vf3], dim=0)
  197. if self.R == 1:
  198. return vf3
  199. return torch.cat([vf1, vf2, vf3], dim=0)
  201. # ------------------------- Temporal Attention -------------------------
  202. class AttentionNet(nn.Module):
  203. """Temporal attention predictor for weighting stationary velocity fields."""
  205. def __init__(self, hidden_channels: int = 16, M: int = 2, R: int = 3) -> None:
  206. super().__init__()
  207. self.fc1 = nn.Linear(1, hidden_channels * 4)
  208. self.fc2 = nn.Linear(hidden_channels * 4, hidden_channels * 8)
  209. self.fc3 = nn.Linear(hidden_channels * 8, hidden_channels * 8)
  210. self.fc4 = nn.Linear(hidden_channels * 8, hidden_channels * 4)
  211. self.fc5 = nn.Linear(hidden_channels * 4, M * R)
  213. def forward(self, t: torch.Tensor) -> torch.Tensor:
  214. out = F.leaky_relu(self.fc1(t), 0.2)
  215. out = F.leaky_relu(self.fc2(out), 0.2)
  216. out = F.leaky_relu(self.fc3(out), 0.2)
  217. out = F.leaky_relu(self.fc4(out), 0.2)
  218. return F.softmax(self.fc5(out), dim=-1)
  220. # ------------------------- TANet -------------------------
  222. class TANet(nn.Module):
  223. """Temporal attention network with RK4 integration over stationary fields."""
  225. def __init__(
  226. self,
  227. C_in: int = 5,
  228. C_hid: Sequence[int] = (16, 32, 64, 128, 256),
  229. inshape: Sequence[int] = (112, 224, 176),
  230. depths: Sequence[int] = (1, 1, 1, 6, 3),
  231. kernels: Sequence[int] = (3, 3, 7, 7, 7),
  232. step_size: float = 0.02,
  233. M: int = 2,
  234. R: int = 3,
  235. device: str = "cuda:0",
  236. ) -> None:
  237. super().__init__()
  238. self.M = int(M)
  239. self.R = int(R)
  240. self.vf_net = CMUNeXt_VFNet_Final(C_in, C_hid, depths, kernels, M=self.M, R=self.R).to(device)
  241. self.att_net = AttentionNet(hidden_channels=16, M=self.M, R=self.R).to(device)
  243. self.h = float(step_size)
  244. self.num_steps = max(1, int(round(1.0 / self.h)))
  245. self.timesteps = torch.arange(self.num_steps, device=device)[:, None] * self.h
  246. self.scale = torch.as_tensor(inshape, device=device, dtype=torch.float32)[None, None, :] - 1.0
  248. def forward(self, vertices: torch.Tensor, volumes: torch.Tensor, return_extras: bool = False):
  249. svfs_all = self.vf_net(volumes)
  250. expected = self.M * self.R
  251. if svfs_all.dim() != 5:
  252. msg = f"vf_net output expects 5D, got {svfs_all.shape}"
  253. raise RuntimeError(msg)
  254. if svfs_all.shape[0] == 3 and svfs_all.shape[-1] == expected:
  255. svfs_all = svfs_all.permute(4, 0, 1, 2, 3).contiguous()
  256. elif svfs_all.shape[0] != expected or svfs_all.shape[1] != 3:
  257. msg = f"Unexpected SVF shape {svfs_all.shape}, expect [MR,3,X,Y,Z] with MR={expected}"
  258. raise RuntimeError(msg)
  260. attention = self.att_net(self.timesteps)[..., None, None]
  262. current_vertices = vertices
  263. trajectory_stats = [] if return_extras else None
  264. for step in range(self.num_steps):
  265. weights = attention[step]
  267. def sample_field(sample_vertices: torch.Tensor) -> torch.Tensor:
  268. raw = self.interpolate(sample_vertices, svfs_all)
  269. return (weights.view(-1, 1, 1) * raw).sum(0, keepdim=True)
  271. k1 = sample_field(current_vertices)
  272. k2 = sample_field(current_vertices + self.h * 0.5 * k1)
  273. k3 = sample_field(current_vertices + self.h * 0.5 * k2)
  274. k4 = sample_field(current_vertices + self.h * k3)
  275. velocity = (k1 + 2 * k2 + 2 * k3 + k4) / 6.0
  276. current_vertices = current_vertices + self.h * velocity
  278. if return_extras:
  279. speed = torch.linalg.vector_norm(velocity[0], dim=-1)
  280. trajectory_stats.append(
  281. {
  282. "t": float((step + 1) * self.h),
  283. "speed_mean": float(speed.mean()),
  284. "speed_p95": float(torch.quantile(speed, 0.95)),
  285. "speed_max": float(speed.max()),
  286. }
  287. )
  289. if not return_extras:
  290. return current_vertices
  292. per_level = {}
  293. offset = 0
  294. for level in range(self.R):
  295. per_level[f"vf{level + 1}"] = svfs_all[offset : offset + self.M].detach()
  296. offset += self.M
  298. extras = {
  299. "svfs_all": svfs_all.detach(),
  300. "per_level": per_level,
  301. "att_weights": attention.squeeze(-1).squeeze(-1).detach(),
  302. "traj_stats": trajectory_stats,
  303. }
  304. return current_vertices, extras
  306. def interpolate(self, vertices: torch.Tensor, fields: torch.Tensor) -> torch.Tensor:
  307. coords = 2.0 * vertices / self.scale - 1.0
  308. coords = coords.repeat(fields.shape[0], 1, 1)
  309. coords = coords[:, :, None, None].flip(-1)
  310. sampled = F.grid_sample(fields, coords, mode="bilinear", padding_mode="border", align_corners=True)
  311. return sampled[..., 0, 0].permute(0, 2, 1)

ddsurfer_tanet_dualstream_cascaded.py at commit 6ea71a4, no license · at the source

Overview

Authors: Chengjin Li1, Wei Zhang1, Xi Zhu1, Yuqian Chen2, Nir A Sochen3, Jarrett Rushmore2,4, Carl‐Fredrik Westin2, Yogesh Rathi2, Lauren J O'Donnell2, Ofer Pasternak2, Fan Zhang1
ORCID iDs: Chengjin Li, Fan Zhang
  1. University of Electronic Science and Technology of China, Chengdu, China
  2. Brigham and Women's Hospital, Harvard Medical School, Boston, Massachusetts, USA
  3. School of Mathematical Sciences, University of Tel Aviv, Tel Aviv, Israel
  4. Department of Anatomy and Neurobiology, Boston University School of Medicine, Boston, Massachusetts, USA
Institutions: University of Electronic Science and Technology of China (China); Brigham and Women's Hospital (United States); Harvard University (United States); Tel Aviv University (Israel); Boston University (United States)
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany), article e76596
Dates: received 27 January 2026; accepted 3 July 2026; published online 23 July 2026; in print July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/advs.76596 · PMID 42489305 · PMCID PMC13393330 · OpenAlex W7170170346
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), methods / tools (subfield)
Methods: Connectivity, Machine learning, fMRI & imaging, Preprocessing
Keywords: cortical surface reconstruction, deep learning, diffusion MRI, neuroimaging, weakly supervised learning
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: National Natural Science Foundation of China (62371107); National Key Research and Development Program of China (2023YFE0118600); Science and Technology Department of Sichuan Province (2026YFHZ0045)
Citations: not cited yet (Europe PMC); 75 references in the paper

Abstract

Cortical surface reconstruction of white matter and pial surfaces from diffusion MRI (dMRI) is critical for neuroimaging analyses, including tractography, connectomics, and multimodal data integration. However, obtaining these surfaces from dMRI data is inherently challenged by its low spatial resolution and poor tissue contrast. Currently, this relies on T1‐weighted images, from which the surfaces are reconstructed and then registered to the dMRI space—a process affected by inaccurate inter‐modality registration. This study introduces DDSurfer, an end‐to‐end deep learning framework that directly generates high‐fidelity cortical surfaces from dMRI data. DDSurfer leverages a novel dual‐stream architecture that processes and synergistically fuses complementary microstructural features from dMRI, learning a diffeomorphic transformation for subject‐specific surface reconstruction. The model is trained using a robust weakly‐supervised strategy with automatically generated pseudo‐ground‐truth surfaces. Extensive evaluations on diverse datasets demonstrate that DDSurfer surpasses traditional methods in geometric accuracy, morphological consistency, and generalization. By providing a computationally efficient and robust T1‐weighted‐independent solution, DDSurfer overcomes a major bottleneck in dMRI, delivering a practical tool to advance accurate dMRI‐centric connectomics and surface‐based investigations. Source code and implementation as an interactive 3D Slicer module are publicly available at: https://github.com/ChengjinLii/DDSurfer.

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

Repositories

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

ChengjinLii/DDSurfer

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6ea71a4994c97d777a637beadd349c3e1a89b087, 28 July 2026
Languages: Python (23), Shell (4)
Size: 40 files, 27 scripts
Software Heritage: not archived
Found in: the text, “Introduction”
Holds: README, environment (dti_processing/environment.yml, dti_processing/requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (14 files), NiBabel (9 files), PyTorch (8 files), SciPy (2 files), SimpleITK (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
28 files
At the source: github.com/ChengjinLii/DDSurfer

pnlbwh/pnlpipe

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 13545b03effe3cbcca828688bbf808e1958b25d8, 12 March 2025
Languages: Python (61), Shell (4), R (1)
Size: 107 files, 66 scripts
Software Heritage: archived
Found in: the text, “DMRI Preprocessing and DTI Parameter Computation”
Holds: README, license file, environment (python_env/environment36.yml, python_env/environment36_gpu.yml, python_env/requirements.txt, pnlpipe_cli/pipecmd/setup.py), tests, 1 notebook
Not found: CITATION.cff, continuous integration, documentation
Tools: pandas (7 files), NumPy (6 files), FreeSurfer (4 files), NiBabel (3 files), ANTs (2 files), data.table (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
68 files
At the source: github.com/pnlbwh/pnlpipe

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

The data that support the findings of this study are available on request from the corresponding author. The data are not publicly available due to privacy or ethical restrictions.

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, pages, dates, 11 authors, 5 keywords, 3 funders, 51 references.

Cite

This paper

Li, C., Zhang, W., Zhu, X., Chen, Y., Sochen, N. A., Rushmore, J., Westin, C., Rathi, Y., O'Donnell, L. J., Pasternak, O., & Zhang, F. (2026). DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI. Advanced science (Weinheim, Baden-Wurttemberg, Germany), e76596. https://doi.org/10.1002/advs.76596

BibTeX

@article{li2026ddsurfer,
author = {Li, Chengjin and Zhang, Wei and Zhu, Xi and Chen, Yuqian and Sochen, Nir A and Rushmore, Jarrett and Westin, Carl‐Fredrik and Rathi, Yogesh and O'Donnell, Lauren J and Pasternak, Ofer and Zhang, Fan},
title = {{DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI}},
journal = {Advanced science (Weinheim, Baden-Wurttemberg, Germany)},
year = {2026},
month = jul,
pages = {e76596},
publisher = {Wiley},
issn = {2198-3844},
doi = {10.1002/advs.76596},
url = {https://doi.org/10.1002/advs.76596},
pmid = {42489305},
pmcid = {PMC13393330}
}

RIS

TY - JOUR
AU - Li, Chengjin
AU - Zhang, Wei
AU - Zhu, Xi
AU - Chen, Yuqian
AU - Sochen, Nir A
AU - Rushmore, Jarrett
AU - Westin, Carl‐Fredrik
AU - Rathi, Yogesh
AU - O'Donnell, Lauren J
AU - Pasternak, Ofer
AU - Zhang, Fan
TI - DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI
T2 - Advanced science (Weinheim, Baden-Wurttemberg, Germany)
J2 - Adv Sci (Weinh)
PY - 2026
DA - 2026/07/23
SP - e76596
SN - 2198-3844
PB - Wiley
DO - 10.1002/advs.76596
UR - https://doi.org/10.1002/advs.76596
LA - en
ER -

CSL-JSON

{
"id": "10.1002/advs.76596",
"type": "article-journal",
"title": "DDSurfer: A Weakly-Supervised Dual-Stream Deep Learning Framework for Cortical Surface Reconstruction From Diffusion MRI",
"container-title": "Advanced science (Weinheim, Baden-Wurttemberg, Germany)",
"author": [
{
"family": "Li",
"given": "Chengjin"
},
{
"family": "Zhang",
"given": "Wei"
},
{
"family": "Zhu",
"given": "Xi"
},
{
"family": "Chen",
"given": "Yuqian"
},
{
"family": "Sochen",
"given": "Nir A"
},
{
"family": "Rushmore",
"given": "Jarrett"
},
{
"family": "Westin",
"given": "Carl‐Fredrik"
},
{
"family": "Rathi",
"given": "Yogesh"
},
{
"family": "O'Donnell",
"given": "Lauren J"
},
{
"family": "Pasternak",
"given": "Ofer"
},
{
"family": "Zhang",
"given": "Fan"
}
],
"container-title-short": "Adv Sci (Weinh)",
"page": "e76596",
"DOI": "10.1002/advs.76596",
"PMID": "42489305",
"PMCID": "PMC13393330",
"ISSN": "2198-3844",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/advs.76596",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
23
]
]
}
}

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-54446-8 [code]
Deep learning-based Desikan-Killiany parcellation of the brain using diffusion MRI.
Journal: Scientific reports
In common: FreeSurfer, NiBabel, PyTorch, 2 other tools, methods / tools, structural MRI / diffusion, 16 references
[2] doi:10.1162/imag.a.1183 [code]
Learning-based segmentation of diffusion-weighted MR images with arbitrary <i>q</i>-space samplings.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: NiBabel, PyTorch, pandas, 2 other tools, methods / tools, structural MRI / diffusion, 10 references
[3] 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, ANTs, FreeSurfer, 5 other tools, methods / tools, structural MRI / diffusion, 5 references
[4] doi:10.1016/j.isci.2026.116671 [code]
A high-resolution functional network-organized atlas of human superficial white matter from ultra-high-field diffusion MRI.
Journal: iScience
In common: ANTs, NiBabel, PyTorch, 3 other tools, methods / tools, structural MRI / diffusion, 6 references
[5] 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, ANTs, FreeSurfer, 5 other tools, structural MRI / diffusion, 4 references
[6] doi:10.1038/s41398-026-04143-x [code]
Neighborhood opportunity, white matter, and cognition in a large pediatric neuroimaging study.
Journal: Translational psychiatry
In common: ANTs, NiBabel, pandas, 2 other tools, structural MRI / diffusion, 2 references, author Fan Zhang
[7] doi:10.1002/nbm.70353 [code]
Automated Surface-Based Segmentation of Deep Gray Matter Regions Based on Diffusion Tensor Images Reveals Unique Age Trajectories Over the Healthy Lifespan.
Journal: NMR in biomedicine
In common: ANTs, FreeSurfer, NiBabel, 2 other tools, structural MRI / diffusion, 5 references
[8] doi:10.1162/imag.a.1352 [code]
Brain-age in ultra-low-field MRI: How well does it work?
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: ANTs, FreeSurfer, NiBabel, 4 other tools, methods / tools, structural MRI / diffusion, 3 references
[9] doi:10.3390/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: SimpleITK, ANTs, NiBabel, 4 other tools, methods / tools, structural MRI / diffusion, 2 references
[10] doi:10.1038/s41467-026-71555-0 [code]
A deep representation learning model to predict response to vagus nerve stimulation.
Journal: Nature communications
In common: ANTs, FreeSurfer, NiBabel, 4 other tools, structural MRI / diffusion, 3 references

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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