CS-INFNet 超详细原理解析（包含RGF + 完整数学公式）

📐 完整数学框架

问题定义

去眩光任务可以建模为：

给定: I_flare = I_clean + F(I_clean, L)
其中 F 是眩光函数，L 是光源

目标: 恢复 I_clean

约束: 有配对的NIR图像 I_nir，提供场景结构先验

🔬 RGF (Region-aware Guided Filter) - 污染图生成

1. RGF 核心原理

RGF基于一个物理观察：

眩光会破坏RGB和NIR之间的梯度一致性，因为眩光主要影响可见光(RGB)，而NIR受影响小。

数学定义

梯度一致性 (Gradient Consistency):

C(x, y) = (∇I_rgb · ∇I_nir) / (|∇I_rgb| · |∇I_nir| + ε)

其中:

• ∇I_rgb = [∂I/∂x, ∂I/∂y] - RGB图像的梯度向量
• ∇I_nir - NIR图像的梯度向量
• · 表示点积（向量内积）
• C ∈ [-1, 1] 是余弦相似度

物理含义:

• 干净区域: RGB和NIR的边缘应该对齐 → C ≈ 1
• 眩光区域: RGB被眩光污染，边缘错位 → C ≈ 0 或负值

2. RGF 计算步骤

Step 1: 计算梯度

使用Sobel算子计算梯度：

Sobel X方向

K_x = [[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]]

Sobel Y方向

K_y = [[-1, -2, -1],
[ 0, 0, 0],
[ 1, 2, 1]]

∇I_x = I ⊗ K_x # 卷积
∇I_y = I ⊗ K_y

RGB梯度 (转为亮度后计算):
L_rgb = 0.299·R + 0.587·G + 0.114·B # 转灰度

∇L_rgb^x = L_rgb ⊗ K_x
∇L_rgb^y = L_rgb ⊗ K_y

NIR梯度:
∇I_nir^x = I_nir ⊗ K_x
∇I_nir^y = I_nir ⊗ K_y

Step 2: 计算梯度方向一致性

点积 (向量内积)

dot_product = ∇L_rgb^x · ∇I_nir^x + ∇L_rgb^y · ∇I_nir^y

梯度幅值

mag_rgb = √((∇L_rgb^x)² + (∇L_rgb^y)² + ε)
mag_nir = √((∇I_nir^x)² + (∇I_nir^y)² + ε)

一致性 (余弦相似度)

consistency = dot_product / (mag_rgb · mag_nir + ε)

值域: consistency ∈ [-1, 1]

Step 3: 不一致性 = 污染

inconsistency = 1.0 - consistency
inconsistency = clamp(inconsistency, 0, 1) # 限制到[0,1]

物理含义:

• inconsistency ≈ 0: RGB-NIR梯度一致 → 无眩光
• inconsistency ≈ 1: 梯度完全不一致 → 强眩光

Step 4: 径向衰减 (Radial Decay)

眩光有径向衰减特性（从光源中心向外衰减）：

1. 估计光源中心 (cx, cy)

brightness = max(R, G, B)
(cx, cy) = weighted_centroid(brightness, top_k=5%)

2. 计算每个像素到中心的距离

dist(x, y) = √((x - cx)² + (y - cy)²)

3. 归一化距离

max_dist = √(H² + W²)
dist_norm = dist / max_dist # [0, 1]

4. 指数衰减

radial_decay = exp(-dist_norm · α) # α=2是衰减系数

数学形式:
D(x, y) = exp(-α · ||p - c|| / ||p_max - c||)

其中:

• p = (x, y) - 当前像素
• c = (cx, cy) - 光源中心
• α - 衰减速率

Step 5: 综合RGF

综合公式

RGF = inconsistency · radial_decay · brightness

归一化到[0, 1]

RGF = (RGF - RGF.min()) / (RGF.max() - RGF.min() + ε)

完整数学表达:

RGF(x,y) = normalize(
(1 - C(x,y)) · D(x,y) · L(x,y)
)

其中:

• C(x,y) - 梯度一致性
• D(x,y) - 径向衰减
• L(x,y) - 亮度 (brightness)

3. RGF 物理直觉

三个因子的作用:

1. 梯度不一致性 (1 - C):
   - 眩光破坏RGB-NIR边缘对齐
   - 检测"哪里有眩光"
2. 径向衰减 D:
   - 眩光强度从光源向外递减
   - 提供空间先验
3. 亮度 L:
   - 眩光通常在亮区
   - 过滤暗区的误检

组合效果: 同时满足三个条件才是强眩光

RGF高 ⟺ 梯度不一致 ∧ 靠近光源 ∧ 高亮度

4. RGF-Enhanced Net: 学习残差修正

零样本RGF相关性只有0.717，需要学习提升。

策略: 物理先验 + 神经网络残差

class RGFEnhancedNet:
def forward(self, rgb, nir):
# 1. 零样本RGF（物理先验，冻结）
cx, cy = estimate_center(rgb)
RGF_physics = PhysicalRGF(rgb, nir, cx, cy) # 不可学习

text
      # 2. 学习残差修正
      residual = RefineNet(rgb, nir, RGF_physics)  # CNN学习

      # 3. 融合
      α = sigmoid(learnable_weight)  # 可学习融合权重
      P_final = RGF_physics + α · residual

      return clamp(P_final, 0, 1)

数学形式:
P(x,y) = RGF_0(x,y) + α · R_θ(x,y | I_rgb, I_nir, RGF_0)

其中:

• RGF_0 - 零样本物理RGF（固定）
• R_θ - 可学习残差网络
• α - 可学习融合权重（初始化小值，保证开始接近物理先验）

训练目标:
min_θ ||P(x,y) - P_gt(x,y)||² + λ₁||R_θ||₁

• 第一项: 与GT污染图的误差
• 第二项: 残差正则化（防止过度偏离物理先验）

🏗️ Stage 1: Coarse Restoration Net (粗修复网络)

1. NAFNet 架构原理

NAFBlock: 无非线性激活的基础块

传统网络使用ReLU/GELU等激活函数，但NAFNet用SimpleGate替代：

class SimpleGate(nn.Module):
def forward(self, x):
x1, x2 = x.chunk(2, dim=1) # 拆成两半
return x1 * x2 # 元素级相乘

数学形式:
SimpleGate(x) = x[:, :C/2] ⊙ x[:, C/2:]

其中 ⊙ 表示Hadamard积（元素级乘法）

为什么有效？

• 乘法是非线性操作（虽然简单）
• 相比ReLU，梯度更平滑，训练更稳定
• 计算量小，速度快

NAFBlock 完整结构

class NAFBlock(nn.Module):
def forward(self, inp):
x = inp

text
      # 1. 深度可分离卷积 + SimpleGate
      x = LayerNorm(x)
      x = Conv1×1(x)              # 升维: C → 2C
      x = DWConv3×3(x)            # 深度卷积
      x = SimpleGate(x)           # 降维: 2C → C
      x = SCA(x)                  # 空间通道注意力
      x = Conv1×1(x)              # 投影回C
      y = inp + β · x             # 残差连接（可学习权重β）

      # 2. FFN (Feed-Forward Network)
      x = LayerNorm(y)
      x = Conv1×1(x)              # C → 2C
      x = SimpleGate(x)           # 2C → C
      x = Conv1×1(x)              # 保持C
      return y + γ · x            # 残差连接（可学习权重γ）

数学表达:

Part 1: Depth-wise Convolution + Gate

h₁ = x + β · Conv₁(SCA(SG(DWConv(Conv₀(LN(x))))))

Part 2: FFN

y = h₁ + γ · Conv₃(SG(Conv₂(LN(h₁))))

其中:

• LN - LayerNorm
• SG - SimpleGate
• SCA - Spatial Channel Attention
• β, γ - 可学习残差权重

SCA (Spatial Channel Attention)

class SCA(nn.Module):
def forward(self, x):
# 全局平均池化
attn = AdaptiveAvgPool2d(1)(x) # (B, C, H, W) → (B, C, 1, 1)

text
      # 通道注意力
      attn = Conv1×1(attn)            # (B, C, 1, 1) → (B, C, 1, 1)

      # 应用注意力
      return x * attn                 # 广播乘法

数学形式:
SCA(x) = x ⊙ σ(Conv(GAP(x)))

其中:

• GAP - Global Average Pooling
• σ - 注意力激活（隐式）

2. 跨谱融合 (Cross-Spectral Fusion)

核心思想

RGB特征向NIR特征"提问"：哪里是真实场景？

class CrossSpectralFusionBlock:
def forward(self, rgb_feat, nir_feat, pollution):
# 1. Query from RGB, Key/Value from NIR
Q = Conv1×1(rgb_feat) # RGB提问
K = Conv1×1(nir_feat) # NIR键
V = Conv1×1(nir_feat) # NIR值

text
      # 2. 简化注意力（避免N×N矩阵）
      attn = σ(Q ⊙ K / √C)   # 元素级注意力
      out = attn ⊙ V         # 加权NIR特征

      # 3. 残差融合
      out = rgb_feat + γ · out

      # 4. 拼接融合
      fused = Conv([rgb_feat, out])

      # 5. 污染自适应（关键！）
      P_resized = resize(pollution, size=(H_feat, W_feat))
      fused = P · fused + (1 - P) · rgb_feat

      return fused

数学表达:

注意力

A = σ((Q ⊙ K) / √d_k)
V_attended = A ⊙ V

融合

F_fused = Conv(concat(F_rgb, F_rgb + V_attended))

污染自适应

F_out = P ⊙ F_fused + (1 - P) ⊙ F_rgb

物理直觉:

• P高 (强眩光区域): 更依赖NIR特征（因为RGB不可信）
• P低 (干净区域): 保留RGB特征

3. U-Net 架构

class CoarseRestorationNet:
def forward(self, rgb_flare, nir, P):
# 输入拼接
x = concat([rgb_flare, nir]) # (B, 4, H, W)

text
      # 编码器 (4 levels)
      x0 = Intro(x)                 # (B, C, H, W)
      x1 = Encoder₁(x0)             # (B, 2C, H/2, W/2)
      x2 = Encoder₂(x1)             # (B, 4C, H/4, W/4)
      x3 = Encoder₃(x2)             # (B, 8C, H/8, W/8)

      # 跨谱融合（最深层）
      nir_feat = NIR_Encoder(nir)   # 单独处理NIR到相同尺度
      x3 = CrossFusion(x3, nir_feat, P)

      # 解码器
      x = Decoder₃(x3)              # (B, 4C, H/4, W/4)
      x = Decoder₂(cat([x, x2]))    # Skip connection
      x = Decoder₁(cat([x, x1]))
      x = Decoder₀(cat([x, x0]))    # (B, C, H, W)

      # 输出投影
      residual = Outro(x)           # (B, 3, H, W)

      # 残差学习 + 污染自适应
      rgb_coarse = rgb_flare + P · residual

      return rgb_coarse, {
          'level0': x0,  # 多尺度特征（供INR使用）
          'level1': x1,
          'level2': x2,
          'level3': x3
      }

关键设计:

1. 残差学习:
   I_coarse = I_flare + P ⊙ R_θ(I_flare, I_nir, P)
   - 只在眩光区域（P高）做修复
   - 干净区域保持不变
2. 多尺度特征: 返回编码器各层特征，供INR使用

🌊 Stage 2: Cross-Spectral INR (跨谱隐式神经表示)

1. INR (Implicit Neural Representation) 基础

核心思想

将图像看作连续函数而非离散像素网格：

传统方法:
Image = 离散网格 I[h, w] ∈ ℝ^(H×W×3)

INR方法:
Image = 连续函数 f: ℝ² → ℝ³
f(x, y) = RGB值

优势:

• 可以查询任意坐标（不限于整数）
• 天然支持超分辨率 (查询更密集的坐标)
• 平滑插值（隐式函数的连续性）

SIREN: Sinusoidal Representation Networks

普通MLP难以拟合高频细节，SIREN用sin激活解决：

class SIRENLayer(nn.Module):
def forward(self, x):
return sin(ω₀ · Linear(x))

数学形式:
h_{l+1} = sin(ω₀ · W_l · h_l + b_l)

为什么用sin？

1. 平滑性:
   - ReLU: 一阶导数不连续
   - sin: 无限可微
2. 周期性:
   - 可以表示高频振荡
   - ω₀控制频率（细节程度）
3. 梯度:
   - ∂sin(x)/∂x = cos(x) 也是周期函数
   - 梯度不会消失或爆炸

权重初始化（关键！）:

第一层

W₁ ~ Uniform(-1/n, 1/n)

其他层

W_l ~ Uniform(-√(6/n)/ω₀, √(6/n)/ω₀)

原因: 确保sin的输入分布合理，输出在有效范围

2. 位置编码 (Positional Encoding)

坐标(x, y)直接输入MLP表达能力有限，需要频率编码：

γ(x) = [sin(2⁰πx), cos(2⁰πx),
sin(2¹πx), cos(2¹πx),
...,
sin(2^(L-1)πx), cos(2^(L-1)πx)]

数学形式:
PE(p) = [sin(2^0·π·p), cos(2^0·π·p), ..., sin(2^(L-1)·π·p), cos(2^(L-1)·π·p)]

作用:

• 将低维坐标映射到高维空间
• 不同频率捕获不同尺度的细节
• L越大，能表示的频率越高

维度变化:
(x, y) ∈ ℝ²
↓ PE (L=64)
γ(x, y) ∈ ℝ^(2×64×2) = ℝ^256

3. Cross-Spectral INR 完整架构

class CrossSpectralINR(nn.Module):
def forward(self, coords, rgb_feat, nir_feat, pollution):
# 1. 位置编码
pos_enc = PositionalEncoding(coords) # (B, N, 256)

text
      # 2. 特征投影（统一维度）
      rgb_emb = Linear(rgb_feat)   # (B, N, D)
      nir_emb = Linear(nir_feat)   # (B, N, D)
      p_emb = Linear(pollution)    # (B, N, D/4)

      # 3. 跨谱融合
      fused = CrossSpectralFusion(rgb_emb, nir_emb, pollution)

      # 4. 拼接条件
      siren_input = concat([pos_enc, fused, p_emb])

      # 5. SIREN预测RGB残差
      rgb_delta = SIREN(siren_input)  # (B, N, 3)

      return rgb_delta

数学完整表达:

位置编码

PE(p) = [sin(2^k·π·p), cos(2^k·π·p)]_{k=0}^{L-1}

特征投影

F_rgb' = W_rgb · F_rgb
F_nir' = W_nir · F_nir
P' = W_P · P

跨谱融合（污染自适应注意力）

A = σ(F_rgb' ⊙ F_nir' / √d)
F_fused = w(P) ⊙ (A ⊙ F_nir') + (1 - w(P)) ⊙ F_rgb'

SIREN

h₀ = concat([PE(p), F_fused, P'])
h_{l+1} = sin(ω₀ · W_l · h_l + b_l)
ΔI = W_out · h_L

最终输出

I_fine = I_coarse + ΔI

4. 跨谱融合 (CrossSpectralFusion)

核心: 污染自适应的注意力机制

class CrossSpectralFusion:
def forward(self, rgb_feat, nir_feat, pollution):
# 1. 轻量注意力
Q = Linear(rgb_feat)
K = Linear(nir_feat)
V = Linear(nir_feat)

text
      A = σ(Q ⊙ K / √D)  # 元素级注意力
      V_att = A ⊙ V

      # 2. 污染自适应权重
      w = σ(Linear(pollution))  # (B, N, D)

      # 3. 自适应融合
      fused = w ⊙ V_att + (1 - w) ⊙ rgb_feat

      # 4. 残差 + 投影
      fused = Linear(fused) + rgb_feat

      return fused

物理直觉:

P → 0 (干净区域):
w → 0, fused ≈ rgb_feat (保留RGB)

P → 1 (强眩光区域):
w → 1, fused ≈ nir_feat (依赖NIR)

5. 选择性采样策略

INR全图推理太慢，采用误差引导采样：

def selective_sampling(rgb_coarse, rgb_gt, P, N=2048):
# 1. 计算误差
error = |rgb_coarse - rgb_gt|.mean(dim=1) # (B, H, W)

text
  # 2. 高误差区域 + 眩光区域
  high_error_mask = (error > threshold) | (P > 0.5)

  # 3. 采样N个点
  for b in range(B):
      ys, xs = where(high_error_mask[b])

      if len(ys) < N:
          # 不足N个，随机补充
          补充随机点
      else:
          # 超过N个，随机选N个
          idx = randperm(len(ys))[:N]
          ys, xs = ys[idx], xs[idx]

      # 归一化到[-1, 1]
      coords = stack([
          2 * xs / (W - 1) - 1,  # 注意用(W-1)！
          2 * ys / (H - 1) - 1
      ])
      coords = clamp(coords, -1, 1)  # 严格限界

  return coords

数学形式:

误差掩码

M(x,y) = 𝟙[||I_coarse - I_gt|| > τ ∨ P(x,y) > 0.5]

采样

S = {(x_i, y_i) | (x,y) ∼ M, i=1..N}

归一化（关键修复！）

x_norm = 2·x/(W-1) - 1
y_norm = 2·y/(H-1) - 1

关键: 使用(W-1)而非W，确保：
x=0 → x_norm=-1
x=W-1 → x_norm=1 ✓

错误写法 x/W:
x=W-1 → (W-1)/W = 1-1/W < 1 ✗
x=W → 1 (但x=W已越界！)

🎯 损失函数设计

1. NIR约束损失

Edge Consistency Loss (边缘一致性)

物理约束: RGB和NIR的边缘应对齐

def nir_edge_consistency_loss(pred_rgb, nir, P):
# 1. 计算梯度
∇pred = Sobel(pred_rgb)
∇nir = Sobel(nir)

text
  # 2. 梯度方向一致性
  consistency = (∇pred · ∇nir) / (|∇pred| · |∇nir| + ε)

  # 3. 损失
  loss = 1 - consistency

  # 4. 污染加权（眩光区域更重要）
  loss = P · loss

  return loss.mean()

数学表达:
L_edge = 𝔼_{x,y}[P(x,y) · (1 - C_edge(x,y))]

C_edge = (∇I_pred · ∇I_nir) / (||∇I_pred|| · ||∇I_nir|| + ε)

Energy Consistency Loss (能量一致性)

物理约束: RGB和NIR的局部能量（亮度）应相关

def nir_energy_consistency_loss(pred_rgb, nir, P):
# 1. 转灰度
pred_gray = 0.299·R + 0.587·G + 0.114·B

text
  # 2. 局部能量（5×5窗口平均）
  E_pred = AvgPool5×5(pred_gray)
  E_nir = AvgPool5×5(nir)

  # 3. 标准化（确保可比性）
  E_pred_norm = (E_pred - μ_pred) / (σ_pred + ε)
  E_nir_norm = (E_nir - μ_nir) / (σ_nir + ε)

  # 4. L2损失
  loss = (E_pred_norm - E_nir_norm)²

  # 5. 污染加权
  loss = P · loss

  return loss.mean()

数学表达:
L_energy = 𝔼_{x,y}[P(x,y) · ||E_norm(I_pred) - E_norm(I_nir)||²]

E(I) = I ⊗ G_{5×5} (局部能量)
E_norm = (E - μ) / σ (标准化)

2. 完整损失函数

Stage 1: Coarse

L_coarse = L1(rgb_coarse, rgb_gt)

Stage 2: INR (如果启用)

L_fine = L1(rgb_fine, rgb_gt)

NIR约束

L_nir = L1(rgb_pred, rgb_gt) +
λ_edge · L_edge(rgb_pred, nir, P) +
λ_energy · L_energy(rgb_pred, nir, P)

总损失

L_total = L_coarse + 2.0 · L_fine + 0.1 · L_nir

数学完整表达:

L_{total} = ||I_{coarse} - I_{gt}||1 +
2·||I{fine} - I_{gt}||1 +
0.1·(||I{pred} - I_{gt}||1 +
0.5·L{edge} +
0.3·L_{energy})

3. NEC 指标 (NIR Edge Correlation)

评估去眩光质量（检测幻觉）：

def NEC(pred_rgb, nir):
# 1. 计算边缘
edge_rgb = Sobel(pred_rgb)
edge_nir = Sobel(nir)

text
  # 2. Pearson相关系数
  corr = Pearson(edge_rgb.flatten(), edge_nir.flatten())

  return corr

数学定义:
NEC = Corr(∇I_{pred}, ∇I_{nir})
= Cov(∇I_{pred}, ∇I_{nir}) / (σ_{pred} · σ_{nir})

解释:

• NEC ≈ 1: 边缘完全一致（理想）
• NEC < 0.5: 可能存在幻觉
• NEC < 0: 严重幻觉（边缘反向）

🔄 两阶段训练策略

训练时间表

Epoch 0-29:
# 只训练Coarse Net
loss = loss_coarse + 0.1 · loss_nir
INR参数不更新（但前向传播，loss权重=0）

Epoch 30-100:
# Coarse + INR联合训练
loss = loss_coarse + 2.0 · loss_fine + 0.1 · loss_nir
INR开始真正训练

为什么这样设计？

1. Coarse先收敛: 提供良好初始化
2. INR延迟启动: 避免早期不稳定
3. 损失权重渐变: 平滑过渡

DDP 配置（关键修复）

错误配置 (导致CUDA非法内存访问):
DDPStrategy(find_unused_parameters=True) # ✗

正确配置:
DDPStrategy(
find_unused_parameters=False, # 关键！
gradient_as_bucket_view=True, # 减少显存拷贝
static_graph=False
)

原因:

• find_unused_parameters=True: DDP追踪每个参数是否被使用
• 前30个epoch INR不用 → DDP检测到"未使用参数"
• 多GPU同步未使用参数的梯度 → 竞争条件 → CUDA错误

解决方案:

让INR从epoch 0就前向传播（但loss权重=0）

loss_fine = INR(...)
if epoch < 30:
loss_fine = loss_fine * 0.0 # 不贡献loss，但有梯度

DDP不会检测到"未使用参数"

📊 完整数据流

输入: I_flare (RGB) + I_nir (NIR)
│
├─> [RGF] 污染估计
│ ├─> 梯度一致性: (1 - C)
│ ├─> 径向衰减: exp(-d/d_max)
│ ├─> 亮度加权: · L
│ └─> P (污染图)
│
├─> [Stage 1: Coarse Net]
│ ├─> 输入: concat(I_flare, I_nir)
│ ├─> U-Net编码: 4 levels
│ ├─> 跨谱融合: CrossFusion(RGB_feat, NIR_feat, P)
│ ├─> U-Net解码: 4 levels + skip connections
│ ├─> 残差输出: I_coarse = I_flare + P·R
│ └─> 多尺度特征: {level0, level1, level2, level3}
│
├─> [Stage 2: INR] (epoch ≥ 30)
│ ├─> 误差引导采样: S ~ (error > τ) ∨ (P > 0.5)
│ ├─> 特征采样: F_rgb, F_nir ← grid_sample(features, S)
│ ├─> 位置编码: PE(S) ∈ ℝ^256
│ ├─> 跨谱融合: CrossFusion(F_rgb, F_nir, P)
│ ├─> SIREN: ΔI ← SIREN(PE, F_fused, P)
│ └─> 精修复: I_fine = I_coarse + ΔI
│
└─> [损失计算]
├─> L_coarse = L1(I_coarse, I_gt)
├─> L_fine = L1(I_fine, I_gt)
└─> L_nir = L1 + λ_edge·L_edge + λ_energy·L_energy

输出: I_clean (去眩光图像)

● 🌟 理论扩展: Neural Implicit Radial Field (NIRF)

基于你提供的文档 flare_removal_theory_analysis.md，我补充神经隐式径向场的理论：

方案B: 神经隐式径向场 (NIRF)

这是文档中提到的原创性方案，结合了极坐标思想和NeRF技术：

核心思想

眩光 = 径向场函数
F(r, θ | features) → (intensity, color_shift, blur)

其中:

• (r, θ) - 极坐标（相对光源中心）
• features - RGB-NIR提取的条件特征

数学框架

1. 极坐标转换:

给定光源中心 (cx, cy)

r(x, y) = √((x - cx)² + (y - cy)²)
θ(x, y) = atan2(y - cy, x - cx)

归一化

r_norm = r / r_max ∈ [0, 1]
θ_norm = (θ + π) / (2π) ∈ [0, 1]

2. 位置编码 (与CS-INR类似):
   PE(r, θ) = [sin(2^k·π·r), cos(2^k·π·r),
   sin(2^k·π·θ), cos(2^k·π·θ)]_{k=0}^{L-1}

3. NIRF MLP:
   class NIRF(nn.Module):
   def forward(self, r, θ, features):
   # 位置编码
   pos_enc = PE(r, θ)

   text
    # 拼接条件
    input = concat([pos_enc, features])
   
    # SIREN预测
    h = SIREN(input)
   
    # 输出眩光属性
    intensity = sigmoid(h[:, 0])      # [0, 1]
    density = softplus(h[:, 1])       # [0, ∞)
    color_shift = tanh(h[:, 2])       # [-1, 1]
    blur_radius = softplus(h[:, 3])   # [0, ∞)
   
    return {
        'intensity': intensity,
        'density': density,
        'color_shift': color_shift,
        'blur_radius': blur_radius
    }

4. 体渲染 (Volume Rendering，借鉴NeRF):

def render_flare(H, W, cx, cy, features):
flare = zeros(H, W, 3)

text
  # 从内向外累积（沿径向）
  for r in sorted(unique_radii):
      # 该半径上的所有点
      points = get_circle_points(cx, cy, r)

      # 查询NIRF
      props = NIRF(r, θ_points, features)

      # Alpha合成
      alpha = 1 - exp(-props['density'] · Δr)
      color = props['intensity'] · (1 + props['color_shift'])

      # 累积
      flare[points] = alpha · color + (1 - alpha) · flare[points]

  # 应用自适应模糊
  flare = adaptive_blur(flare, props['blur_radius'])

  return flare

数学表达 (NeRF风格):

径向累积

C(x,y) = ∫0^{r{max}} T(r) · σ(r,θ) · c(r,θ) dr

T(r) = exp(-∫_0^r σ(s,θ) ds) # 透明度
σ(r,θ) = MLP_density(r,θ) # 密度
c(r,θ) = MLP_color(r,θ) # 颜色

物理约束损失

1. 重建损失

L_recon = L1(I - F_nirf, I_gt)

2. 径向单调性（眩光从中心向外递减）

L_radial = 𝔼[ReLU(I(r+1) - I(r))]

3. 平滑性（眩光应平滑）

L_smooth = TV(F_nirf)

总损失

L = L_recon + λ₁·L_radial + λ₂·L_smooth

优势

1. 连续表示: 无离散化误差
2. 物理约束: 径向单调性自然嵌入
3. 紧凑: 只存储MLP权重（不是整张图）
4. 泛化: 任意分辨率

🔬 与文档方案的对应关系

方案A: 径向梯度一致性

文档提到的梯度方向场方案与RGF类似：

RGF用梯度大小一致性

C = (∇I_rgb · ∇I_nir) / (|∇I_rgb| · |∇I_nir|)

方案A用梯度方向一致性

grad_angle = atan2(∇I_y, ∇I_x)
radial_angle = atan2(y - cy, x - cx)
consistency = cos(|grad_angle - radial_angle|)

改进: 方向比幅值更鲁棒

方案C: 双路径建模

对应论文中的散射-反射分解：

散射路径（雾状光束）

F_scatter = ScatteringModel(img, nir)

建模: Mie散射 + 径向衰减

反射路径（光斑光环）

F_reflection = ReflectionModel(img, light_source)

建模: Fresnel方程 + 高斯核

非线性组合

F_total = F_scatter + F_reflection + α·F_scatter·F_reflection

● 📚 总结：核心公式速查表

RGF (Pollution Map)

P(x,y) = normalize((1 - C(x,y)) · D(x,y) · L(x,y))

C(x,y) = (∇I_{rgb} · ∇I_{nir}) / (||∇I_{rgb}|| · ||∇I_{nir}|| + ε)
D(x,y) = exp(-α·||p - c||/||p_{max} - c||)
L(x,y) = max(R, G, B)

Coarse Net (NAFBlock)

SimpleGate

SG(x) = x_{[:C/2]} ⊙ x_{[C/2:]}

NAFBlock

h = x + β·Conv(SCA(SG(DWConv(Conv(LN(x))))))
y = h + γ·Conv(SG(Conv(LN(h))))

残差输出

I_{coarse} = I_{flare} + P ⊙ R_θ(I_{flare}, I_{nir}, P)

Cross-Spectral INR

位置编码

PE(p) = [sin(2^k·π·p), cos(2^k·π·p)]_{k=0}^{L-1}

跨谱融合

A = σ(F_{rgb} ⊙ F_{nir} / √d)
F_{fused} = w(P) ⊙ (A ⊙ F_{nir}) + (1 - w(P)) ⊙ F_{rgb}

SIREN

h_{l+1} = sin(ω_0 · W_l · h_l + b_l)

输出

ΔI = SIREN(PE(p), F_{fused}, P)
I_{fine} = I_{coarse} + ΔI

SIREN权重初始化

W_1 ∼ Uniform(-1/n, 1/n)
W_l ∼ Uniform(-√(6/n)/ω_0, √(6/n)/ω_0)

NIR约束损失

L_{edge} = 𝔼[P · (1 - (∇I_{pred} · ∇I_{nir})/(||∇I_{pred}|| · ||∇I_{nir}||))]

L_{energy} = 𝔼[P · ||E_{norm}(I_{pred}) - E_{norm}(I_{nir})||^2]

L_{total} = L_{coarse} + 2·L_{fine} + 0.1·(L_1 + 0.5·L_{edge} + 0.3·L_{energy})

坐标归一化（关键修复）

正确

x_{norm} = 2·x/(W-1) - 1, \quad x_{norm} ∈ [-1, 1]

错误（导致grid_sample越界）

x_{norm} = 2·x/W - 1, \quad x_{norm} ∈ [-1, 1-2/W]

请根据文件内的综述 ，批判并且改进我的这个方法，
我认为我的方法：
1 不够合理不够鲁棒
2 理论严谨性和新颖性不足
3 整体两阶段不好，我希望变成单阶段
4 整体方案新颖性不足
希望你和我讨论 ，批判，重构，改进我的方案
希望你能够引用和观摩顶级论文，再给我改进意见

实际上我的整体流程思路是，因为我是RGB IR 联合去除眩光重建任务，算是first work ，所以我想要根据RGF 得到一个 眩光污染等级map，然后后续重建仅重现污染区域内，并且根据眩光污染的程度去决定IR 参与重建的程度 （整体思路是这样），也算是我整体流程的创新点，当前并没有RGB-IR 联合去除眩光重建的文章和方法流程 ，但你说的很多我确实没考虑到，你能根据我的思路，帮助我设计一个完整的单阶段的方案 以及 告诉我文章该怎么写等 希望你引用顶级论文，并且理论严谨，具有原创性和新颖性

1 LLVIP+Flare7k 合成数据 作为前期训练，我也有自采 5000+对灰度图像+IR 的眩光数据集
2 可以全神经网络，但是当前RGF 效果很好
3 不考虑
4 暂时只考虑算法
5 自由提出结构改进建议