【论文阅读 | TPAMI 2026 | CDTFusion：跨域与跨任务协同的红外-可见光图像融合方法】

4.2.1 第一阶段#

第一阶段的核心是 SITS（Swap Image Translation Strategy）。其任务不是直接生成最终融合图，而是先把红外特征和可见光特征拉到一个共享的适配域中。为此，论文引入三类约束：

1. 全局域约束：通过域判别器约束 transferred features 进入共享域；
2. 局部统计约束：通过均值与方差约束缩短局部域距离；
3. 交叉重建约束：保证迁移后的特征仍保留足够的模态内容，不至于在对齐过程中洗掉有效信息。

4.2.2 第二阶段#

第二阶段在冻结第一阶段跨域模块的基础上，进一步处理跨任务交互。作者分别构造融合分支与分割分支，然后引入 TIQM（Task Interaction & Query Module），让融合分支不是被动接收语义特征，而是主动从任务交互特征中查询对自己有用的语义信息。

这个设计的好处在于，分割特征不会被粗暴拼接到融合特征里，而是先经过交互建模，再做针对性映射。

4.3.1 第一阶段入口#

• fmb_train_step1.py
• pos_train_step1.py
• whu_train_step1.py

这一阶段负责编码双模态特征、执行双向 transfer、训练域判别器、施加局部均值方差约束，并完成交叉重建。

4.3.2 第二阶段入口#

• fmb_train_step2.py
• pos_train_step2.py
• whu_train_step2.py

这一阶段负责冻结跨域模块，构造融合/分割双分支，通过 TIQM 完成跨任务映射，并联合优化融合输出与分割输出。

4.4.1 关键判断#

SITS 在于它显式构造了一个位于红外域与可见光域之间的共享适配域。对于红外-可见光融合，最棘手的问题从来不是两种模态能否同时输入网络，而是两者在亮度分布、纹理表达和目标显著方式上的天然失配会在特征层持续累积，最终表现为细节变钝、边界混乱和局部伪增强。

SITS 的做法相当于先把两种模态从各自原生域中“拉出来”，压到一个更利于后续融合的中间空间里，再把跨任务语义映射建立在这个相对稳定的特征基础上。因此，它不是普通的预处理模块，而是整套框架成立的前提层。

4.4.2 共享适配域的目标函数#

论文先用全局域判别器约束未迁移特征，再反过来逼迫迁移后的特征落入共享适配域。对应公式为：

其中 $a$ 与 $b$ 分别表示红外域和可见光域标签，$c$ 表示共享适配域标签。这里最关键的不是判别器本身，而是它在训练中扮演了“两步走”的角色：先学会区分原始域，再逼迫迁移后特征变得不可区分。

在局部层面，论文进一步把局部窗口特征的域定义为均值与方差之和：

这组公式把 SITS 的思路钉得很清楚：Eq.(1)-Eq.(2) 负责把双模态特征压向全局不可分的共享域，Eq.(3)-Eq.(6) 负责把这种不可分继续落实到局部窗口统计层面。 也正因为如此，SITS 不只是 feature transfer，而是一个完整的共享适配域构造过程。

4.4.3 编码器与迁移模块的代码对应#

编码器位于：

• util/encoder.py

主要类包括：

• EncoderVi
• EncoderIr

这两个编码器分别处理可见光与红外输入，并输出高维特征表示。随后，跨域迁移模块位于：

• util/transfer.py

对应类：

• transfer

从实现逻辑看，这个 transfer 模块不是典型的 image-to-image translator，而更像是一种跨模态条件重标定与卷积映射结构。它先拼接双模态特征，再生成 channel weights 去调制另一模态特征，最后输出 transferred feature。它更接近“条件式特征迁移”，而不是生成式翻译。

对应实现可以按张量维度拆开来看。设编码器输出的可见光特征与红外特征分别为 opt 与 sar，其典型尺寸均为 [B, 512, H, W]。那么 transfer 的前向过程可以写成：

1
# opt: [B, 512, H, W]，可见光编码特征
2
# sar: [B, 512, H, W]，红外编码特征
3
# 这里的 H、W 一般已经是编码器下采样后的空间尺寸
4

5
def forward(self, opt, sar):
6

7
    # 1) 沿通道维拼接双模态特征
8
    # [B, 512, H, W] + [B, 512, H, W] -> [B, 1024, H, W]
9
    x1 = self.concat([opt, sar])
10

11
    # 2) 三层卷积提取联合上下文
12
    # conv1: [B, 1024, H, W] -> [B, 1024, H, W]
13
    x1 = self.relu1(self.conv1(x1))
14
    # conv2: [B, 1024, H, W] -> [B, 512, H, W]
15
    x1 = self.relu2(self.conv2(x1))
16
    # conv3: [B, 512, H, W] -> [B, 512, H, W]
17
    x1 = self.relu3(self.conv3(x1))
18

19
    # 3) 生成通道权重
20
    # [B, 512, H, W] -> [B, 512, H, W]
21
    channel_weights = self.channel_weights_conv(x1)
22

23
    # 4) 用联合上下文得到的权重去调制另一模态特征
24
    # sar: [B, 512, H, W]
25
    # channel_weights: [B, 512, H, W]
26
    # 逐元素相乘后仍为 [B, 512, H, W]
27
    x2 = sar * channel_weights
28

29
    # 5) 将原始参考特征 opt 与被调制后的 x2 再次拼接
30
    # [B, 512, H, W] + [B, 512, H, W] -> [B, 1024, H, W]
31
    x3 = self.concat_x2([opt, x2])
32

33
    # 6) 再经过三层卷积，输出迁移后的适配特征
34
    # 最终输出尺寸恢复为 [B, 512, H, W]
35
    x3 = self.relu4(self.conv1(x3))
36
    x3 = self.relu5(self.conv2(x3))
37
    x3 = self.relu6(self.conv3(x3))
38

39
    return x3

这段实现说明得更彻底：SITS 里的 transfer 不是直接把一端特征“翻译成另一端”，而是先从双模态联合上下文中生成通道级调制，再把这种调制施加到另一模态特征上，最后输出共享适配域中的新表示。 因此，它更接近条件式特征重标定，而不是生成式翻译。

4.4.3 全局域约束与局部统计约束#

SITS 能否真正形成共享域，关键并不只在 transfer 本身，还在后续约束。

全局域约束对应的实现主要位于：

• util/discriminator.py

其中：

• DomDiscriminator

负责区分原始红外域与可见光域特征。训练时，代码先让判别器学习区分真实域，再冻结判别器，把 transfer 后的双模态特征共同推向中间域标签。

第一阶段训练脚本中的相关写法：

1
domain_vi_labels = torch.ones(vi_features.size(0), 1).to(device)
2
domain_ir_labels = torch.zeros(ir_features.size(0), 1).to(device)
3
domain_un_labels = (domain_ir_labels + domain_vi_labels) / 2

这比论文里的 adapted domain label 更直观。可见光记为 1，红外记为 0，而共享适配域直接压到 0.5。

局部统计约束则位于：

• util/MeanVarianceLoss.py

对应类：

• LocalMeanVarianceLoss

它通过局部窗口上的均值与方差差异，约束 transfer 后红外/可见光特征在局部统计意义上更接近。其实现思路基本就是：

1
mean1 = avg_pool(feature1)
2
mean2 = avg_pool(feature2)
3
variance1 = avg_pool(feature1**2) - mean1**2
4
variance2 = avg_pool(feature2**2) - mean2**2

简化地说：

• global constraint 负责让特征“进入同一个域”；
• local constraint 负责让它们在这个域里“贴得更近”。

两者一个偏分布级，一个偏局部统计级，是明显互补关系。

4.6.1 关键判断#

TIQM 的必要性来自一个常被忽视的事实：融合任务与分割任务虽然都处理同一场景，但它们在特征需求上并不一致。融合更关心亮度、纹理、边缘和局部连续性，分割更关心语义类别、区域一致性和目标边界。若直接把分割特征拼到融合特征上，高层语义很容易以过强的方式压制低层重建细节，导致融合图变成“语义更强，但观感更硬”的结果。

TIQM 选择了更克制的路径。它先显式建模融合任务与分割任务的交互关系，再由融合特征主动查询交互特征中的有用语义信息。这样一来，分割分支提供的不是整块灌入的高层语义，而是可被按需取用的结构先验。也正因此，TIQM 更接近一种桥接机制，而不是简单的特征融合技巧。

4.6.2 任务交互与查询的数学定义#

TIQM 的前半段先用多头自注意力捕获融合特征与分割特征之间的交互关系：

其中 $F_{sf}$ 由 $F_{fus}$ 与 $F_{seg}$ 拼接得到，$\phi_L$ 表示归一化操作，$\phi_M$ 表示 MLP。论文真正想强调的是，这一步不是直接把两类特征混在一起，而是先学到“它们如何交互”。

随后，再以融合特征为参照生成 query：

并完成查询式映射：

最终融合图由解码器输出：

这组公式对应的核心思想很明确：Eq.(8)-Eq.(9) 先定义交互关系，Eq.(10)-Eq.(13) 再把交互关系变成融合分支可按需调用的语义增益。 这里不是让高层语义特征直接压到低层融合特征上，而是让融合分支带着自己的需求去查询交互特征。这也是 TIQM 比 concatenate 和 summation 更像“桥接机制”而不是“特征拼接技巧”的原因。

4.6.3 代码对应#

相关实现位于：

• util/taskinteraction.py

对应类：

• TaskInteraction

从代码流程看，它会先把 fusion feature 和 segmentation feature 拼接并压回统一维度，再通过 self-attention 学习两任务之间的交互表示。随后，再以 fusion branch 为 query，对交互特征执行查询映射，得到更适合融合任务使用的语义增强结果。

对应实现同样可以按维度变化逐步展开。设融合分支特征 x1 与分割分支特征 x2 的典型尺寸均为 [B, 512, H, W]，则 TIQM 的核心路径可以写成：

1
# x1: [B, 512, H, W]，fusion branch 特征
2
# x2: [B, 512, H, W]，segmentation branch 特征
3

4
def forward(self, x1, x2):
5

6
    # 1) 先沿通道维拼接两路特征
7
    # [B, 512, H, W] + [B, 512, H, W] -> [B, 1024, H, W]
8
    x = torch.cat((x1, x2), dim=1)
9

10
    # 2) 用 1x1 卷积把通道压回原维度，并与 fusion 特征做残差相加
11
    # concat(x): [B, 1024, H, W] -> [B, 512, H, W]
12
    # x = x1 + concat(x) 后仍为 [B, 512, H, W]
13
    x = x1 + self.concat(x)
14
    x = self.bn(x)
15

16
    # 3) 将二维特征图展平成 token 序列
17
    # [B, 512, H, W] -> [B, 512, H*W] -> [H*W, B, 512]
18
    x = x.view(x.shape[0], x.shape[1], -1).permute(2, 0, 1)
19

20
    # 4) 用自注意力建模 fusion / segmentation 的交互关系
21
    # 输入输出尺寸都为 [H*W, B, 512]
22
    x, _ = self.self_attention(x, x, x)
23

24
    # 5) 再恢复成二维特征图
25
    # [H*W, B, 512] -> [B, 512, H*W] -> [B, 512, H, W]
26
    x = x.permute(1, 2, 0).view(x1.shape)
27

28
    # 6) 经 MLP 进一步整合交互特征
29
    x = self.mlp(x)
30

31
    # 7) 以 fusion 特征生成 query，以交互特征生成 key / value
32
    # 三者尺寸均保持 [B, 512, H, W]
33
    x1 = self.bn_x1(x1)
34
    x2 = self.bn_x2(x)
35
    q = self.linear_q(x1)
36
    k = self.linear_k(x2)
37
    v = self.linear_v(x2)
38

39
    # 8) 再次展平，准备做 batch matrix multiplication
40
    # [B, 512, H, W] -> [B, 512, H*W]
41
    q = q.view(q.size(0), q.size(1), -1)
42
    k = k.view(k.size(0), k.size(1), -1)
43
    v = v.view(v.size(0), v.size(1), -1)
44

45
    # 9) 计算 attention score
46
    # q^T: [B, H*W, 512]
47
    # k:   [B, 512, H*W]
48
    # 输出 [B, H*W, H*W]
49
    attention_scores = torch.bmm(q.transpose(1, 2), k)
50
    attention_weights = torch.nn.functional.softmax(attention_scores, dim=2)
51

52
    # 10) 用 attention 权重对 value 做加权汇聚
53
    # attention_weights: [B, H*W, H*W]
54
    # v^T:               [B, H*W, 512]
55
    # 输出 weighted_sum: [B, H*W, 512]
56
    weighted_sum = torch.bmm(attention_weights, v.transpose(1, 2))
57

58
    # 11) 恢复成二维特征图
59
    # [B, H*W, 512] -> [B, 512, H, W]
60
    weighted_sum = weighted_sum.view(weighted_sum.size(0), self.in_channels, x2.size(2), x2.size(3))
61

62
    # 12) 与 fusion branch 做残差相加，得到最终增强后的融合特征
63
    # 输出尺寸仍为 [B, 512, H, W]
64
    output = x1 + weighted_sum
65

66
    return output

这段实现比摘要式描述更清楚：TIQM 不是把分割特征直接贴到融合特征上，而是先把两者关系编码成交互特征，再让 fusion branch 以 query 的方式从中检索自己真正需要的结构线索。

4.8.1 第一阶段损失#

第一阶段训练脚本中，总损失由三部分组成：recon_loss、domain_loss 和 m_v_loss。它们分别对应交叉重建约束、全局域约束和局部均值方差约束。

从代码实现看，论文里较为抽象的总目标，被拆成了更直接的工程版本。若按训练流程与维度变化去看，第一阶段脚本的关键路径可以概括为：

1
# vi_images: [B, 3, 512, 512]，可见光输入
2
# ir_images: [B, 1, 512, 512]，红外输入
3

4
# 1) 编码器提取双模态特征
5
# vi_features: [B, 512, H, W]
6
# ir_features: [B, 512, H, W]
7
vi_features = encoder_1(vi_images)
8
ir_features = encoder_2(ir_images)
9

10
# 2) 双向 transfer，得到共享适配域特征
11
# vi_allin: [B, 512, H, W]，可见光 -> 适配域
12
# ir_allin: [B, 512, H, W]，红外 -> 适配域
13
vi_allin = transfer_vi_to_ir(vi_features, ir_features)
14
ir_allin = transfer_ir_to_vi(ir_features, vi_features)
15

16
# 3) 用适配特征重建对侧模态输入
17
# ir_out: [B, 1, 512, 512]
18
# vi_out: [B, 3, 512, 512]
19
ir_out = decoder_2(vi_allin)
20
vi_out = decoder_1(ir_allin)
21

22
# 4) 计算交叉重建损失
23
reir_loss = F.l1_loss(ir_out, ir_images) + ssim_loss(ir_out, ir_images)
24
revi_loss = F.l1_loss(vi_out, vi_images) + ssim_loss(vi_out, vi_images)
25
recon_loss = revi_loss + reir_loss
26

27
# 5) 计算适配域上的全局判别损失
28
# domain_vi_a_pred / domain_ir_a_pred 的尺寸一般为 [B, 1]
29
domain_vi_a_pred = domain_discriminator(vi_allin)
30
domain_ir_a_pred = domain_discriminator(ir_allin)
31
domain_loss_fake = bce_loss(domain_vi_a_pred, domain_un_labels) + bce_loss(domain_ir_a_pred, domain_un_labels)
32
domain_loss = domain_loss_fake
33

34
# 6) 计算局部均值方差损失
35
mean_loss, variance_loss = loss_calculator(ir_allin, vi_allin)
36
m_v_loss = mean_loss + variance_loss
37

38
# 7) 合成第一阶段总损失
39
# total_loss = 重建 + 域对齐 + 局部统计对齐
40
total_loss = recon_loss + lambda_domain * domain_loss + lambda_mean_vari * m_v_loss

这里还有一个值得注意的细节：论文里的重建约束主要用结构相似性表述，但代码实现中实际混入了 L1 与 SSIM。

4.8.2 第二阶段损失#

第二阶段训练时，总损失由 seg_loss 与 fus_loss 组成。其中分割损失由 Dice Loss 和 Cross Entropy 共同构成，这符合语义分割训练的常见设置。若按训练流程与维度变化去看，第二阶段脚本的关键路径可以写成：

1
# vi_images:  [B, 3, 512, 512]，可见光输入
2
# ir_images:  [B, 1, 512, 512]，红外输入
3
# seg_images: [B, 512, 512] 或 [B, H, W]，语义标签
4

5
# 1) 先将可见光图像转换到 YCrCb，仅取亮度 Y 通道用于融合监督
6
# rgb_images_ycrcb: [B, 3, 512, 512]
7
# opt_images:       [B, 1, 512, 512]
8
rgb_images_ycrcb = RGB2YCrCb_Cuda1(vi_images)
9
opt_images = rgb_images_ycrcb[:, 0:1, :, :]
10

11
# 2) 通过冻结的一阶段模块得到共享适配域特征
12
# vi_allin / ir_allin: [B, 512, H, W]
13
with torch.no_grad():
14
    vi_features = encoder_1(vi_images)
15
    ir_features = encoder_2(ir_images)
16
    vi_allin = transfer_vi_to_ir(vi_features, ir_features)
17
    ir_allin = transfer_ir_to_vi(ir_features, vi_features)
18

19
# 3) segmentation branch
20
# seg_features: [B, 512, H, W]
21
# seg_out:      [B, num_classes, 512, 512]
22
seg_features = mixer(vi_allin, ir_allin)
23
seg_out = decoder_3(seg_features)
24
seg_loss = dice_loss(seg_out, seg_images) + 0.5 * criterion(seg_out, seg_images)
25

26
# 4) fusion branch
27
# fus_features:       [B, 512, H, W]
28
# fus_features_taski: [B, 512, H, W]
29
# fus_out:            [B, 1, 512, 512]
30
fus_features = mixer_f(vi_allin, ir_allin)
31
fus_features_taski = taskinteraction(fus_features, seg_features)
32
fus_out = decoder_4(fus_features_taski)
33
fus_loss = fusionloss(opt_images, ir_images, fus_out)
34

35
# 5) 第二阶段总损失 = 分割监督 + 融合监督
36
total_loss = seg_loss + fus_loss

这段实现说明得很清楚：第二阶段不是简单地同时训练两个头，而是先用两路 mixer 分别形成 segmentation / fusion 表示，再通过 TIQM 把分割分支学到的结构信息重新注入 fusion branch。 也正因此，seg_loss + fus_loss 并不是并列的两个损失，而是共享适配域之上的联合优化。

融合损失则位于：

• util/loss_ssim.py

从实现上看，代码不是直接照论文里的双源 SSIM 公式逐项写开，而是先构造一个由红外与可见光平均形成的 target，再对融合输出计算 SSIM 损失。

4.9.1 第一阶段前向#

第一阶段的完整路径可以概括为：

1. 用 EncoderVi 提取可见光特征；
2. 用 EncoderIr 提取红外特征；
3. 通过双向 transfer 执行跨域迁移；
4. 通过 DomDiscriminator 完成真实域判别和共享域约束；
5. 用局部均值方差损失约束迁移后特征接近；
6. 通过两个重建头交叉重建红外与可见光图像。

第一阶段的职责是先完成跨域特征整理。

4.9.2 第二阶段前向#

第二阶段在冻结第一阶段模块后，路径会变成：

1. 获取已经对齐到共享域的双模态特征 vi_allin / ir_allin，其典型尺寸为 [B, 512, H, W]；
2. 送入分割分支 mixer，得到 seg_features，再由 decoder_3 输出 seg_out，尺寸通常为 [B, num_classes, 512, 512]；
3. 送入融合分支 mixer_f，得到 fus_features，尺寸仍为 [B, 512, H, W]；
4. 用 TaskInteraction 建模跨任务交互并完成查询式映射，输出 fus_features_taski，尺寸不变；
5. 由融合头 decoder_4 输出单通道融合结果 fus_out，典型尺寸为 [B, 1, 512, 512]；
6. 联合优化 seg_loss + fus_loss。

如果按信息流理解，这一步真正完成的不是简单的多头输出，而是“共享适配域之上的跨任务桥接”。分割分支负责学习结构语义，融合分支负责保持低层细节，而 TIQM 负责把前者转化为后者可用的增益。

4.9.3 测试时的彩色图恢复策略#

测试脚本如 fmb_test.py 中，网络并不是直接生成三通道彩色融合图，而是先预测单通道亮度结果，再把它回填到可见光图像的 HSV 空间中作为 V 通道，最后恢复 RGB 彩图。

如果按推理流程展开，关键路径是：

1
# rgb_image: 原始 RGB 图像，尺寸 [H0, W0, 3]
2
# ir_image:  原始红外图像，尺寸 [H0, W0]
3
# transform 后统一变为 512 x 512
4

5
# 1) 输入图像转张量
6
# rgb_tensor: [1, 3, 512, 512]
7
# ir_tensor:  [1, 1, 512, 512]
8
rgb_tensor = transform(rgb_image).unsqueeze(0).to(device)
9
ir_tensor = transform(ir_image).unsqueeze(0).to(device)
10

11
# 2) 编码 + transfer
12
# test_vi_allin / test_ir_allin: [1, 512, H, W]
13
test_vi_features = encoder_1(rgb_tensor)
14
test_ir_features = encoder_2(ir_tensor)
15
test_vi_allin = transfer_vi_to_ir(test_vi_features, test_ir_features)
16
test_ir_allin = transfer_ir_to_vi(test_ir_features, test_vi_features)
17

18
# 3) segmentation branch 与 fusion branch
19
# test_seg_features / test_fus_features: [1, 512, H, W]
20
test_seg_features = mixer(test_vi_allin, test_ir_allin)
21
test_fus_features = mixer_f(test_vi_allin, test_ir_allin)
22

23
# 4) 通过 TIQM 获得增强后的融合特征
24
# test_fus_features_taski: [1, 512, H, W]
25
test_fus_features_taski = taskinteraction(test_fus_features, test_seg_features)
26

27
# 5) 输出单通道融合亮度图
28
# generated_fus_images: [1, 1, 512, 512]
29
generated_fus_images = decoder_4(test_fus_features_taski)
30

31
# 6) 截断到 [0, 1] 并转成 uint8
32
# fus_img_pred: [512, 512]
33
fus_img_pred = generated_fus_images.cpu().detach().numpy().squeeze()
34
fus_img_pred = np.uint8(255.0 * fus_img_pred)
35

36
# 7) 回填到 HSV 的 V 通道，再转回 RGB
37
img_hsv[:, :, 2] = fus_img_pred
38
modifited_rgb_img = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2RGB)

网络本体负责预测融合亮度主结果，而彩色外观则由可见光图像原有的色度信息配合 HSV-V 通道回填来恢复。因此，源码里 fusion head 的输出通道不必直接对应完整 RGB，但最终仍然能得到彩色融合结果。

5.1.1 数据集覆盖#

论文主要在三套数据集上验证方法：

• FMB，14 类，训练集 4880 对，测试集 1120 对
• Potsdam，6 类，训练集 3388 对，测试集 1089 对
• WHU-OPT-IR，7 类，训练集 5460 对，测试集 1540 对

这三套数据既覆盖常见红外-可见光融合场景，也包含后续分割任务需要的语义标注，因此适合验证“融合质量 + 下游任务可用性”这条主线。

5.1.2 训练配置#

论文给出的设置包括：

• batch size = 4
• 总 epoch = 50
• 其中 stage1 为 20 epoch
• stage2 为 30 epoch
• 初始学习率为 1e-4
• 超参数设置为 α=1, β=0.5, δ=0.5, λ=0.5
• 模型参数量为 142.87M
• 3090 上 512×512 输入的推理速度为 13.23 FPS

5.1.3 指标体系#

论文同时报告融合指标与分割指标。融合侧主要包括：

• EN
• SD
• SF
• AG

分割侧主要包括：

• mAcc
• mIoU

此外，论文还给出额外的检测验证，用于说明方法的迁移性不只局限于分割任务。

5.2.1 主结论#

作者提到：

只优化融合视觉质量是不够的。只有同时处理跨域差异与跨任务特征鸿沟，才能得到既保留细节、又有利于后续语义理解的融合结果。

因此，这部分结果不能拆开看。Table IV 负责证明融合质量提升，Tables V-VII 负责证明这种提升能迁移到分割任务，Table VIII 则进一步说明这种迁移并非只对一个下游任务成立。三组结果合起来，才构成文章真正的主证据链。

5.2.2 融合主实验#

论文将 CDTFusion 与 FusionGAN、U2Fusion、TarDAL、SwinFusion、CDDFuse、MetaFusion、SegMif 等方法对比。Fig.8 的可视化首先给出两个直观现象：

1. 跨域差异被更好抑制，因此车牌、树木、农田纹理等细节保留更完整；
2. 跨任务桥接更有效，因此建筑、车辆、村庄等目标边缘更清晰。

对应的定量结果见 Table IV。作者特别强调，CDTFusion 的平均 SD 相比第二名 MetaFusion 提升 4.02%，平均 AG 提升 5.17%。这组结果表明，模型收益并非来自简单的亮度增强或对比度拉高，而是来自更稳定的细节保留与边缘表达。

若把可视化与定量结果合起来看，可以得到更准确的判断：SITS 主要缓解的是细节被跨域差异抹平的问题，TIQM 主要缓解的是目标边缘在跨任务映射中变糊的问题。 前者更偏纹理，后者更偏结构，这也是 Fig.8 与 Table IV 能彼此对上的原因。

5.2.3 分割主实验#

分割结果才是这篇论文最关键的外部验证。因为如果融合图只是“看起来更好”，但对后续语义任务没有帮助，那么 crossing task 这一主张就站不住。

论文在 FMB、Potsdam 和 WHU-OPT-IR 三套数据上报告分割结果。Tables V-VII 给出的总结是：

• 在 FMB 上，mAcc 相比第二名提升 0.6%，mIoU 提升 2.4%
• 在 Potsdam 上，mAcc 提升 0.8%，mIoU 提升 1.2%
• 在 WHU-OPT-IR 上，mAcc 提升 1.7%，mIoU 提升 1.9%

这组结果说明，CDTFusion 的改进不是只停留在融合统计指标上，而是确实转化成了更强的语义判别能力。Fig.9 的可视化进一步补足了这一判断。作者特别指出，其他方法在相邻车辆之间更容易出现错误黏连，在森林与农田环带等结构复杂区域更容易出现边界混淆，而 CDTFusion 在统一分割框架下仍能保持更清晰的结构边界。

因此，这里的证据是：跨任务桥接确实把分割任务学到的结构信息，转化成了对融合结果有用的表示增益。

5.3.1 SITS 消融#

相关可视化见 Fig.5，定量对比见 Table I。作者将 SITS 与直接特征提取版本 DEFusion、加入自监督重建的 SEFusion 进行对比，并指出采用 swap image translation 的版本在 Potsdam 上相较第二名 SEFusion 带来 EN +0.8%、SD +3.6%、SF +2.3%、AG +2.8% 的提升。

这里最关键的结论不是“swap 有用”，而是：仅靠直接提特征或普通自监督重建，并不足以稳定构造共享适配域。 真正起作用的是双向 swap translation、全局域约束、局部统计约束与交叉重建共同组成的整套训练机制。

5.3.2 global-local constraint 消融#

相关特征可视化见 Fig.6，定量结果见 Table III。论文比较了不使用域约束、只用 global constraint、只用 local constraint，以及二者联合使用四种设置，并报告 G-LC 相较第二名 GC 在 Potsdam 上带来 EN +0.3%、SD +0.8%、SF +4.1%、AG +2.9% 的提升。

这组结果说明，global 与 local 不是可互相替代的两个小技巧，而是职责不同的两层约束。global constraint 负责把特征推向共享域，解决的是域级可分性；local constraint 负责压缩窗口级统计差异，解决的是共享域内部是否足够贴合。两者联用，SITS 才真正成立。

5.3.3 TIQM 消融#

相关可视化见 Fig.7，定量结果见 Table II。论文将 TIQM 与简单拼接、简单相加以及不使用任务交互的版本比较，并报告 Task I&Q 相较第二名 Concatenate 在 Potsdam 上带来 mAcc +1.5%、mIoU +1.5%。

这组结果的意义在于，它把 TIQM 从“加了 attention 的模块”重新还原成“桥接机制”。直接拼接只是信息并置，直接相加只是信息叠加，只有 Task I&Q 明确回答了“融合分支究竟该从分割分支取什么”。因此，它证明的不是某种注意力写法更强，而是交互 + 查询这一结构逻辑本身更合理。

5.4.1 分割迁移#

前文 Tables V-VII 与 Fig.9 已经表明，CDTFusion 在三套数据集上的分割指标与边界质量都具有稳定优势。这意味着本文的融合收益不是停留在图像统计层，而是能进一步转化为语义结构判别能力。

5.4.2 检测迁移#

论文还在 M3FD 上给出目标检测验证，以说明方法不仅对分割有帮助，也对检测有帮助。对应可视化见 Fig.10，定量结果见 Table VIII。作者在正文中给出的结论是：mAP50 相比第二名方法提升 0.4%。