从零搭建光电仿真引擎（四）：光学仿真与辐射传输

一位架构师视角下的光电仿真引擎从零构建实战指南

前言

在国防军工、航空航天、安防监控、自动驾驶等领域，光电场景仿真技术扮演着越来越重要的角色。从红外制导系统的算法验证，到无人机光电载荷的性能评估，再到自动驾驶可见光/红外融合感知算法的训练与测试------高质量的光电仿真引擎能够大幅降低实物试验成本、缩短研发周期、提升系统可靠性。

然而，与游戏引擎、通用渲染引擎不同，光电仿真引擎有其独特的技术挑战：它不仅要生成"看起来像"的图像，更要保证图像在物理上的准确性------光谱分布、辐射强度、热特性、大气传输效应、探测器响应等每一个环节都需要基于物理原理精确建模。

本文将以架构师的视角，从零开始系统性地讲解如何构建一个支持可见光与红外双波段的光电场景仿真引擎。我们将从最基础的架构设计出发，逐层深入场景建模、材质光谱、大气传输、热特性求解、辐射传输、探测器成像等核心模块，每一个模块都将深入探讨其物理原理、算法选型、架构设计与工程实现。

目标读者

本文主要面向以下读者群体：

光电仿真工程师：正在或有志于从事光电场景仿真系统开发
系统架构师/技术负责人：需要对光电仿真系统有全局性理解，以做出正确的技术选型
红外/可见光成像算法工程师：希望理解成像链路的完整物理过程
国防军工/安防领域的技术人员：需要评估或构建光电仿真验证系统

阅读本文需要具备以下基础：

扎实的C/C++编程基础
基本的计算机图形学知识
一定的物理光学和辐射度学基础
基本的热传导理论知识

本册为《从零搭建光电仿真引擎》第四册，涵盖第四篇：光学仿真与辐射传输，聚焦辐射传输基础、可见光渲染路径与红外辐射仿真路径。

[第10章辐射传输基础与求解框架](#第10章辐射传输基础与求解框架 "#%E7%AC%AC10%E7%AB%A0-%E8%BE%90%E5%B0%84%E4%BC%A0%E8%BE%93%E5%9F%BA%E7%A1%80%E4%B8%8E%E6%B1%82%E8%A7%A3%E6%A1%86%E6%9E%B6")
[第11章可见光渲染路径](#第11章可见光渲染路径 "#%E7%AC%AC11%E7%AB%A0-%E5%8F%AF%E8%A7%81%E5%85%89%E6%B8%B2%E6%9F%93%E8%B7%AF%E5%BE%84")
[第12章红外辐射仿真路径](#第12章红外辐射仿真路径 "#%E7%AC%AC12%E7%AB%A0-%E7%BA%A2%E5%A4%96%E8%BE%90%E5%B0%84%E4%BB%BF%E7%9C%9F%E8%B7%AF%E5%BE%84")

第四篇：光学仿真与辐射传输

光电仿真引擎的核心在于对辐射传输过程的精确求解。无论是可见光还是红外波段，光线从光源出发，经过大气传输、场景表面相互作用、最终到达探测器的整个物理过程，都可以统一在辐射传输方程（Radiative Transfer Equation, RTE）的数学框架之下。然而，统一的物理方程并不意味着统一的求解策略------可见光以反射散射为主、红外以热发射为主的物理差异，决定了二者在求解路径、加速策略、采样方法上必须做出不同的架构选择。

本篇将从辐射传输方程出发，系统梳理各类求解方法的原理与适用场景，深入探讨可见光与红外两条仿真路径的架构设计思路，并从架构师视角分析二者的统一与分离策略。

第10章辐射传输基础与求解框架

辐射传输是光电仿真的物理内核。本章将从辐射传输方程出发，建立求解框架的数学基础，然后逐一分析光线追踪、蒙特卡洛、离散纵标、有限体积等主流求解方法的原理与适用边界。在此基础上，我们将讨论求解器的架构设计------包括参数配置、进度管理、结果存储等工程问题，并以架构师的视角给出不同方法的精度-效率权衡矩阵。

10.1 辐射传输方程（RTE）：物理意义与数学表达

辐射传输方程描述了辐射亮度（Radiance）在介质中沿传播路径的变化规律。在光学仿真中，我们关心的核心物理量是谱辐射亮度 $Lλ(r,s^,t) L_\lambda(\mathbf{r}, \hat{\mathbf{s}}, t)$ Lλ(r,s^,t)，其物理意义是：在位置 $r\mathbf{r}$ r 处、沿方向 $s^ \hat{\mathbf{s}}$ s^ 传播、波长为 $λ\lambda$ λ 的辐射亮度，单位为 $W/(m2⋅sr⋅μm)\text{W}/(\text{m}^2 \cdot \text{sr} \cdot \mu\text{m})$ W/(m2⋅sr⋅μm)。

稳态（不随时间变化）的辐射传输方程形式如下：
$dLλ(r,s^) ds =−αλ(r)Lλ(r,s^)−σλ(r)Lλ(r,s^)+αλ(r) Lbλ (r)+ σλ(r) 4π ∫4π pλ(s^′,s^)Lλ(r,s^′)dΩ′ \frac{dL_\lambda(\mathbf{r}, \hat{\mathbf{s}})}{ds} = -\alpha_\lambda(\mathbf{r}) L_\lambda(\mathbf{r}, \hat{\mathbf{s}}) - \sigma_\lambda(\mathbf{r}) L_\lambda(\mathbf{r}, \hat{\mathbf{s}}) + \alpha_\lambda(\mathbf{r}) L_{b\lambda}(\mathbf{r}) + \frac{\sigma_\lambda(\mathbf{r})}{4\pi} \int_{4\pi} p_\lambda(\hat{\mathbf{s}}', \hat{\mathbf{s}}) L_\lambda(\mathbf{r}, \hat{\mathbf{s}}') d\Omega'$ dsdLλ(r,s^)=−αλ(r)Lλ(r,s^)−σλ(r)Lλ(r,s^)+αλ(r)Lbλ(r)+4πσλ(r)∫4πpλ(s^′,s^)Lλ(r,s^′)dΩ′

其中：

左侧 $dLλ ds \frac{dL_\lambda}{ds}$ dsdLλ 表示沿路径 $ss$ s 方向的辐射亮度变化率
第一项 $−αλLλ -\alpha_\lambda L_\lambda$ −αλLλ 为吸收项 ： $αλ \alpha_\lambda$ αλ 是吸收系数（单位 $m−1\text{m}^{-1}$ m−1），描述介质对辐射的吸收衰减
第二项 $−σλLλ -\sigma_\lambda L_\lambda$ −σλLλ 为散射衰减项 ： $σλ \sigma_\lambda$ σλ 是散射系数，描述辐射因向外散射而减少
第三项 $αλ Lbλ \alpha_\lambda L_{b\lambda}$ αλLbλ 为热发射项 ： $Lbλ L_{b\lambda}$ Lbλ 是黑体辐射亮度（由普朗克定律给出），描述介质自身的热发射
第四项为散射增益项 ： $pλ(s^′,s^) p_\lambda(\hat{\mathbf{s}}', \hat{\mathbf{s}})$ pλ(s^′,s^) 是相函数（Phase Function），描述从方向 $s^′\hat{\mathbf{s}}'$ s^′ 散射到方向 $s^ \hat{\mathbf{s}}$ s^ 的概率分布

引入消光系数 $βλ=αλ+σλ \beta_\lambda = \alpha_\lambda + \sigma_\lambda$ βλ=αλ+σλ 和单次散射反照率 $ωλ=σλ/βλ \omega_\lambda = \sigma_\lambda / \beta_\lambda$ ωλ=σλ/βλ，方程可以写为更紧凑的形式：
$dLλ ds =−βλLλ+αλ Lbλ + σλ4π ∫4π pλ(s^′,s^)Lλ(r,s^′)dΩ′ \frac{dL_\lambda}{ds} = -\beta_\lambda L_\lambda + \alpha_\lambda L_{b\lambda} + \frac{\sigma_\lambda}{4\pi} \int_{4\pi} p_\lambda(\hat{\mathbf{s}}', \hat{\mathbf{s}}) L_\lambda(\mathbf{r}, \hat{\mathbf{s}}') d\Omega'$ dsdLλ=−βλLλ+αλLbλ+4πσλ∫4πpλ(s^′,s^)Lλ(r,s^′)dΩ′

这是一个典型的积分-微分方程，其难点在于：散射增益项中包含了对所有入射方向的积分，这意味着任意一点沿任意方向的辐射亮度都依赖于该点所有方向上的辐射亮度------方程是全局耦合的。对于三维非均匀介质，解析解几乎不存在，必须依赖数值方法。

边界条件是RTE求解的另一关键要素。在光电仿真中，常见的边界条件包括：

光源边界：太阳、月亮、目标自身热辐射等已知辐射源
地表/目标表面边界：反射、发射、透射特性由BRDF/发射率模型描述
无穷远边界：通常假设为零（真空环境）或已知的背景辐射

在工程实现中，我们通常将RTE的求解分解为两个层面：

介质内传输：大气、水体等参与介质中的辐射传输，需要完整求解RTE
表面相互作用：目标表面的反射、折射、发射，作为边界条件处理

对于大多数地面光电仿真场景，大气是主要的参与介质，而目标表面的相互作用则通过表面模型来描述。这种"体-面"耦合的求解策略，是后续章节讨论的基础。

10.2 求解方法概述：光线追踪、蒙特卡洛、离散纵标、有限体积

RTE的数值求解方法众多，每种方法都有其适用场景和局限性。从架构设计的角度，理解各类方法的核心思想和适用边界，是做出正确技术选型的前提。

10.2.1 光线追踪法（Ray Tracing）

光线追踪的核心思想是：沿着光线的传播路径，逐段计算辐射亮度的变化。对于一条从探测器出发（反向追踪）或从光源出发（正向追踪）的光线，其在介质中的传输可以通过比尔-朗伯定律的微分形式逐步积分：
$Lλ(s)=Lλ(0)e −τλ(s) +∫0sαλ(s′) Lbλ (s′)e −τλ(s′,s) ds′ L_\lambda(s) = L_\lambda(0) e^{-\tau_\lambda(s)} + \int_0^s \alpha_\lambda(s') L_{b\lambda}(s') e^{-\tau_\lambda(s', s)} ds'$ Lλ(s)=Lλ(0)e−τλ(s)+∫0sαλ(s′)Lbλ(s′)e−τλ(s′,s)ds′

其中 $τλ(s1,s2)= ∫s1s2 βλ(s′′)ds′′ \tau_\lambda(s_1, s_2) = \int_{s_1}^{s_2} \beta_\lambda(s'') ds''$ τλ(s1,s2)=∫s1s2βλ(s′′)ds′′ 是两点之间的光学厚度。

光线追踪法的优势在于：

物理直观：与光线传播的物理图像高度一致，易于理解和实现
灵活性强：可以处理任意几何形状和非均匀介质
天然适合成像：直接以像素为单位组织计算，输出即为图像

其局限性在于：

对于强散射介质（如云雾），光线会发生大量散射，追踪成本急剧上升
难以高效处理漫反射等全局光照问题（需要追踪大量光线）

10.2.2 蒙特卡洛法（Monte Carlo, MCM）

蒙特卡洛方法通过随机抽样大量光子（或光线）的传播路径，用统计平均的方式估计辐射亮度分布。每一个光子的生命周期包括：发射、随机行走（散射）、吸收或逸出边界。

蒙特卡洛方法的核心优势：

精度高：在样本量足够大时，可以获得几乎无偏的结果
适用性广：可以处理任意复杂的几何、介质分布和相函数
天然并行：每个光子的路径独立，易于并行化

其局限性在于：

收敛慢 ：误差与 $N \sqrt{N}$ N 成反比，要将精度提高一个数量级，样本量需增加两个数量级
计算量大：对于高精度要求，计算成本可能高得不可接受
噪声问题：结果包含随机噪声，需要额外的降噪处理

10.2.3 离散纵标法（Discrete Ordinates, $SN S_N$ SN）

离散纵标法将辐射传输方程中的角度变量离散化为有限个离散方向（纵标），将积分-微分方程转化为一组耦合的偏微分方程组。

具体来说，将立体角 $4π4\pi$ 4π 离散为 $NN$ N 个方向 $s^i \hat{\mathbf{s}}$ i s^i（ $i=1,2,...,Ni=1,2,...,N$ i=1,2,...,N），对应的权重为 $wi w_i$ wi，则散射积分近似为：
$∫4π p(s^′,s^)L(s^′)dΩ′≈ ∑j=1N p( s^j , s^i )L( s^j )wj \int$ {4\pi} p(\hat{\mathbf{s}}', \hat{\mathbf{s}}) L(\hat{\mathbf{s}}') d\Omega' \approx \sum_{j=1}^N p(\hat{\mathbf{s}}_j, \hat{\mathbf{s}}_i) L(\hat{\mathbf{s}}_j) w_j ∫4πp(s^′,s^)L(s^′)dΩ′≈j=1∑Np(s^j,s^i)L(s^j)wj

$SN S_N$ SN方法的优势：

计算效率高 ：对于一维/二维平板问题， $SN S_N$ SN 方法效率极高
结果光滑：没有蒙特卡洛的噪声问题
成熟度高：已有大量成熟的求解器和代码库

其局限性在于：

维度灾难 ：三维问题的离散方向数急剧增长（ $NN$ N 通常取8、12、16等，三维下方向数为 $N(N+2)N(N+2)$ N(N+2)）
射线效应：离散方向可能导致虚假的辐射分布（Ray Effect）
几何灵活性差：难以处理复杂的不规则几何形状

10.2.4 有限体积法（Finite Volume Method, FVM）

有限体积法将计算域划分为若干控制体（网格单元），对每个控制体积分RTE，得到辐射亮度在单元界面上的通量平衡方程。

FVM的优势：

守恒性好：天然满足辐射能量守恒
几何适应性强：可以使用非结构化网格处理复杂几何
与CFD兼容：可以方便地与计算流体力学（CFD）耦合

其局限性在于：

角度离散仍有挑战：空间离散用有限体积，角度离散仍需结合离散纵标或其他方法
计算量较大：三维问题的网格和角度离散都带来较大的计算量

方法选择的初步思考

从光电仿真引擎的角度，我们需要回答一个关键问题：应该以哪种方法作为主求解器？

对于成像类光电仿真（即输出为二维图像的场景），光线追踪法是最自然的选择------因为成像过程本身就是"从每个像素出发，沿视线方向积分辐射亮度"的过程。但光线追踪需要与其他方法配合：

大气传输的预计算可以使用 $SN S_N$ SN 或蒙特卡洛方法
复杂参与介质（如云、烟）中的传输可能需要蒙特卡洛方法
表面反射的全局光照可以使用路径追踪（光线追踪的扩展）

因此，一个成熟的光电仿真引擎往往采用混合求解策略：以光线追踪为主框架，在不同的物理子问题上调用最合适的求解器。

10.3 光线追踪在光电仿真中的应用：正向追踪 vs 反向追踪

光线追踪是光电仿真中最核心的求解方法，但有两种基本的追踪方向：正向追踪和反向追踪。二者的选择直接影响求解效率和实现复杂度。

10.3.1 正向追踪（Forward Ray Tracing）

正向追踪从光源出发，追踪光线经过大气传输、表面反射/折射、最终到达探测器的过程。其物理图像最直观------光线实际就是从光源发出的。

正向追踪的C++伪代码如下：

cpp 复制代码

// 正向光线追踪：从光源出发，追踪到探测器
Spectrum forwardRayTrace(const Ray& rayFromLight, int depth) {
    if (depth > maxDepth) return Spectrum(0.0);

    // 找到最近的交点（表面或介质边界）
    SurfaceHit hit;
    if (!scene.intersect(rayFromLight, hit)) {
        // 光线逸出场景，可能到达背景或探测器
        return evaluateBackground(rayFromLight);
    }

    Spectrum L(0.0);

    // 表面发射（热辐射）
    L += hit.material->emission(hit.normal, -rayFromLight.dir);

    // 表面反射：根据BRDF采样反射方向
    Vector3 reflectedDir;
    Spectrum brdfValue;
    float pdf;
    hit.material->sampleBRDF(hit.normal, -rayFromLight.dir, 
                             reflectedDir, brdfValue, pdf);

    // 递归追踪反射光线
    Ray reflectedRay(hit.point + hit.normal * EPS, reflectedDir);
    Spectrum reflectedL = forwardRayTrace(reflectedRay, depth + 1);

    float cosTheta = dot(hit.normal, reflectedDir);
    L += brdfValue * reflectedL * cosTheta / pdf;

    // 介质中的吸收和发射（沿路径积分）
    // ... 体渲染项 ...

    return L;
}

正向追踪的问题在于：绝大多数从光源发出的光线永远不会到达探测器。对于成像仿真来说，我们只关心到达探测器的那些光线，但正向追踪中大部分计算都浪费在了不会被记录的光线上。这使得正向追踪在成像仿真中的效率极低。

10.3.2 反向追踪（Backward Ray Tracing）

反向追踪从探测器（或相机）的每个像素出发，逆着光线传播方向追踪，寻找这条光线最终来自哪个光源。这是计算机图形学中标准的光线追踪方式。

反向追踪的核心思想利用了亥姆霍兹互易性（Helmholtz Reciprocity）：在稳态、线性、非旋光介质中，光线从A到B的传输和从B到A的传输是对称的。这意味着我们可以安全地反向追踪，最终结果与正向追踪一致。

cpp 复制代码

// 反向光线追踪：从探测器/像素出发，向场景中追踪
Spectrum backwardRayTrace(const Ray& rayFromCamera, int depth) {
    if (depth > maxDepth) return Spectrum(0.0);

    SurfaceHit hit;
    if (!scene.intersect(rayFromCamera, hit)) {
        // 打到环境光/背景
        return evaluateEnvironment(rayFromCamera);
    }

    Spectrum L(0.0);

    // 1. 直接光照：对每个光源采样，计算直接贡献
    for (const auto& light : scene.lights) {
        // 从交点向光源采样
        Vector3 lightDir;
        float lightDist;
        Spectrum Li = light->sample(hit.point, lightDir, lightDist);

        // 检测阴影（中间是否有遮挡）
        if (scene.isOccluded(hit.point + hit.normal * EPS, lightDir, lightDist))
            continue;

        // BRDF * 入射光 * 余弦项
        Spectrum f = hit.material->evaluateBRDF(
            hit.normal, -rayFromCamera.dir, lightDir);
        float cosTheta = std::max(0.0f, dot(hit.normal, lightDir));
        L += f * Li * cosTheta;
    }

    // 2. 间接光照：采样BRDF，递归追踪反射方向
    Vector3 sampledDir;
    Spectrum brdfValue;
    float pdf;
    hit.material->sampleBRDF(hit.normal, -rayFromCamera.dir, 
                             sampledDir, brdfValue, pdf);

    if (pdf > 0.0f) {
        Ray reflectedRay(hit.point + hit.normal * EPS, sampledDir);
        Spectrum indirectL = backwardRayTrace(reflectedRay, depth + 1);
        float cosTheta = std::max(0.0f, dot(hit.normal, sampledDir));
        L += brdfValue * indirectL * cosTheta / pdf;
    }

    // 3. 自身发射（热辐射等）
    L += hit.material->emission(hit.normal, -rayFromCamera.dir);

    // 4. 介质传输衰减（大气吸收/散射）
    // ... 大气透射率 ...

    return L;
}

反向追踪的优势在于：每一条光线都对最终图像有贡献，计算效率远高于正向追踪。对于成像类仿真，反向追踪是事实上的标准。

10.3.3 何时需要正向追踪？

尽管反向追踪在成像仿真中效率更高，但以下场景仍然需要正向追踪或混合追踪：

聚焦光源效应：如激光雷达、探照灯等高度定向的光源，正向追踪可以更高效地计算光斑分布
参与介质中的多次散射：在云雾等强散射介质中，光线方向随机化严重，反向追踪的优势减弱
辐照度计算：当需要计算表面接收的总辐照度（而非成像）时，正向追踪可能更直接
光路可逆性不成立的场景：如非线性光学效应、荧光材料等

在架构设计上，我们建议以反向追踪为主框架，同时保留正向追踪的接口，用于特定场景的求解。二者共享场景管理、求交计算、材质评估等底层模块，仅追踪方向和采样策略不同。

10.4 光学厚度与比尔-朗伯定律

光学厚度（Optical Depth / Optical Thickness）是辐射传输中的核心概念，它量化了辐射在介质中传输时的衰减程度。

定义：沿路径从 $s1 s_1$ s1 到 $s2 s_2$ s2 的光学厚度为：
$τλ(s1,s2)= ∫s1s2 βλ(s)ds \tau_\lambda(s_1, s_2) = \int_{s_1}^{s_2} \beta_\lambda(s) ds$ τλ(s1,s2)=∫s1s2βλ(s)ds

其中 $βλ=αλ+σλ \beta_\lambda = \alpha_\lambda + \sigma_\lambda$ βλ=αλ+σλ 是消光系数。

比尔-朗伯定律（Beer-Lambert Law）描述了单色平行光在均匀吸收介质中的指数衰减：
$Lλ= Lλ,0 ⋅e −αλ⋅l L_\lambda = L_{\lambda,0} \cdot e^{-\alpha_\lambda \cdot l}$ Lλ=Lλ,0⋅e−αλ⋅l

其中 $ll$ l 是路径长度。当考虑散射时，将 $αλ \alpha_\lambda$ αλ 替换为 $βλ \beta_\lambda$ βλ：
$Lλ= Lλ,0 ⋅e −βλ⋅l = Lλ,0 ⋅e −τλ L_\lambda = L_{\lambda,0} \cdot e^{-\beta_\lambda \cdot l} = L_{\lambda,0} \cdot e^{-\tau_\lambda}$ Lλ=Lλ,0⋅e−βλ⋅l=Lλ,0⋅e−τλ

比尔-朗伯定律是光线追踪中计算大气衰减的基础。但在光电仿真中，我们需要注意几个重要的扩展：

10.4.1 非均匀介质的数值积分

大气不是均匀介质------温度、压强、气溶胶浓度都随高度变化。因此，消光系数 $βλ(s) \beta_\lambda(s)$ βλ(s) 是路径位置的函数，需要对路径进行数值积分。

工程上常用的方法是分段均匀近似：将大气按高度分为若干层，每层内假设消光系数均匀。对于一条斜程路径，计算其在各层中的路径长度，分别计算光学厚度后求和。

cpp 复制代码

// 沿路径计算大气光学厚度的分段积分实现
float computeAtmosphericOpticalDepth(
    const Vector3& start, const Vector3& end, 
    float wavelength, const AtmosphereModel& atm) {
    
    const int NUM_STEPS = 32;  // 分段数，精度与效率的权衡
    float totalTau = 0.0f;
    
    Vector3 direction = end - start;
    float totalDist = direction.length();
    direction /= totalDist;
    
    float stepLen = totalDist / NUM_STEPS;
    
    for (int i = 0; i < NUM_STEPS; ++i) {
        // 取段中点计算消光系数（中点法，二阶精度）
        float t = (i + 0.5f) * stepLen;
        Vector3 midPoint = start + direction * t;
        
        float altitude = midPoint.y;  // 假设y轴向上
        float beta = atm.getExtinctionCoeff(altitude, wavelength);
        
        totalTau += beta * stepLen;
    }
    
    return totalTau;
}

// 透射率 = exp(-光学厚度)
float computeTransmittance(float tau) {
    return std::exp(-tau);
}

10.4.2 发射-吸收耦合

在红外波段，介质不仅吸收辐射，还会因为自身温度而发射辐射。此时，沿路径的辐射亮度变化不仅有衰减，还有发射的增益。

对于热平衡介质（吸收系数等于发射系数，基尔霍夫定律），沿路径的辐射亮度传输公式为：
$Lλ(s)=Lλ(0)e−τ(0,s)+∫0sαλ(s′) Lbλ (T(s′))e−τ(s′,s)ds′ L_\lambda(s) = L_\lambda(0) e^{-\tau(0,s)} + \int_0^s \alpha_\lambda(s') L_{b\lambda}(T(s')) e^{-\tau(s',s)} ds'$ Lλ(s)=Lλ(0)e−τ(0,s)+∫0sαλ(s′)Lbλ(T(s′))e−τ(s′,s)ds′

其中 $Lbλ (T) L_{b\lambda}(T)$ Lbλ(T) 是温度 $TT$ T 下的黑体光谱辐射亮度（普朗克函数）。

这个公式的物理意义很清晰：

第一项：起点处的辐射亮度，经过路径衰减后到达终点
第二项：路径上每一点的热发射，经过该点到终点的衰减后到达终点

在工程实现中，这个积分同样可以通过分段积分计算：

cpp 复制代码

// 红外路径积分：包含衰减和热发射
Spectrum integrateThermalPath(
    const Vector3& start, const Vector3& end,
    const Spectrum& L_start, const AtmosphereModel& atm,
    const std::function<Spectrum(float)>& blackbodyAtAltitude) {
    
    const int NUM_STEPS = 64;  // 红外需要更高精度
    
    Spectrum L = L_start;  // 初始辐射亮度
    
    Vector3 direction = end - start;
    float totalDist = direction.length();
    direction /= totalDist;
    float stepLen = totalDist / NUM_STEPS;
    
    // 从起点向终点积分
    for (int i = 0; i < NUM_STEPS; ++i) {
        float t = (i + 0.5f) * stepLen;
        Vector3 midPoint = start + direction * t;
        float altitude = midPoint.y;
        
        // 本段的消光和发射
        Spectrum beta = atm.getExtinctionSpectrum(altitude);
        Spectrum alpha = atm.getAbsorptionSpectrum(altitude);
        Spectrum Lb = blackbodyAtAltitude(altitude);
        
        float tau_step = (beta * stepLen).average();  // 简化：假设波段内beta变化小
        float transmittance = std::exp(-tau_step);
        
        // 本段的衰减 + 发射贡献
        // 精确公式：dL/ds = -beta*L + alpha*Lb
        // 数值解：L_{i+1} = L_i * exp(-beta*ds) + (alpha*Lb/beta) * (1 - exp(-beta*ds))
        Spectrum emissionContribution = (alpha / beta) * Lb * (1.0f - transmittance);
        L = L * transmittance + emissionContribution;
    }
    
    return L;
}

注意上面代码中的关键公式：对于均匀段，RTE有解析解：
$L(s+Δs)=L(s)e−βΔs+αβLb(1−e−βΔs)L(s+\Delta s) = L(s) e^{-\beta \Delta s} + \frac{\alpha}{\beta} L_b \left(1 - e^{-\beta \Delta s}\right)$ L(s+Δs)=L(s)e−βΔs+βαLb(1−e−βΔs)

这个解析解比简单的欧拉法精度高得多，特别是在光学厚度较大的情况下。这是一个值得在架构层面统一的优化点------所有涉及体传输的路径积分都应该使用这个解析步进公式，而非一阶近似。

10.5 求解器架构设计：求解参数、进度管理、结果存储

一个工业级的辐射传输求解器，不仅仅是一个"计算函数"，而是一个完整的子系统，包含参数配置、任务调度、进度追踪、结果存储、错误处理等多个维度。本节从架构设计的角度，讨论求解器的核心组件设计。

10.5.1 求解参数体系

求解参数是求解器的输入配置，决定了求解的精度、速度和输出格式。在设计上，需要区分物理参数 和数值参数：

cpp 复制代码

// 求解参数结构设计
struct SolverParams {
    // === 物理参数 ===
    float wavelength_min;      // 最小波长 (μm)
    float wavelength_max;      // 最大波长 (μm)
    int   wavelength_bins;     // 光谱采样点数
    
    enum class Band {
        VISIBLE,    // 可见光 0.4-0.7 μm
        NIR,        // 近红外 0.7-1.4 μm
        MWIR,       // 中波红外 3-5 μm
        LWIR,       // 长波红外 8-14 μm
        CUSTOM      // 自定义波段
    };
    Band band;
    
    // === 数值参数 ===
    int   max_ray_depth;       // 最大光线追踪深度
    int   samples_per_pixel;   // 每像素采样数（蒙特卡洛降噪用）
    int   atmosphere_steps;    // 大气传输分段数
    
    // 加速结构参数
    enum class BVHQuality { LOW, MEDIUM, HIGH };
    BVHQuality bvh_quality;
    
    // === 输出参数 ===
    bool output_radiance;      // 是否输出辐射亮度图
    bool output_temperature;   // 是否输出温度图（红外）
    bool output_depth;         // 是否输出深度图
    bool output_segmentation;  // 是否输出目标分割
    
    // === 精度控制 ===
    float convergence_threshold;  // 收敛阈值（相对误差）
    int   max_iterations;         // 最大迭代次数
};

设计要点：

物理参数与数值参数分离：物理参数由仿真需求决定，数值参数由精度-效率权衡决定。架构上的分离有助于用户理解和调参。
预设波段枚举：常用波段（可见光、中波、长波红外）提供预设，减少用户配置工作量。
多通道输出：光电仿真往往不仅需要图像，还需要深度、温度、分割等辅助数据。求解器应支持多通道同时输出。

10.5.2 进度管理与中断

光电仿真任务可能运行数分钟到数小时。良好的进度管理和可中断性是工程可用性的关键。

cpp 复制代码

// 进度回调接口设计
class ISolverProgressCallback {
public:
    virtual ~ISolverProgressCallback() = default;
    
    // 返回 false 请求中断求解
    virtual bool onProgress(float percent, const std::string& stage) = 0;
    
    // 估计剩余时间（秒）
    virtual void onETAUpdate(float remainingSeconds) {}
};

// 求解器基类
class RadiationSolver {
public:
    virtual ~RadiationSolver() = default;
    
    // 设置进度回调
    void setProgressCallback(std::shared_ptr<ISolverProgressCallback> cb) {
        m_progressCb = std::move(cb);
    }
    
    // 执行求解
    virtual SolverResult solve(const SolverParams& params) = 0;
    
protected:
    // 工具函数：检查是否需要中断
    bool checkProgress(float percent, const std::string& stage) {
        if (m_progressCb) {
            return m_progressCb->onProgress(percent, stage);
        }
        return true;  // 继续执行
    }
    
    std::shared_ptr<ISolverProgressCallback> m_progressCb;
};

设计要点：

回调接口抽象：进度回调通过接口注入，求解器不依赖具体的UI框架（可以是命令行、GUI、Web等）。
可中断设计：进度回调返回布尔值，表示是否继续执行。这使得用户可以在任何阶段安全地中止仿真。
ETA估算：提供剩余时间估算，提升用户体验。估算算法可以基于已完成像素的平均耗时外推。

10.5.3 结果存储设计

求解结果的存储设计直接影响后续分析的便利性。光电仿真的结果通常包含：

辐射亮度图像（二维数组，每个像素是光谱值）
元数据（仿真参数、时间戳、场景描述）
辅助通道（深度、温度、标签等）

cpp 复制代码

// 求解结果结构
struct SolverResult {
    // 基本信息
    std::string timestamp;
    SolverParams params;
    
    // 图像尺寸
    int width;
    int height;
    
    // 主输出：辐射亮度图
    // 存储格式：行优先，每个像素包含 spectrum_samples 个波长采样
    std::vector<float> radiance_image;  // size = width * height * spectrum_samples
    
    // 辅助通道
    std::vector<float> depth_map;       // 深度图
    std::vector<float> temperature_map; // 温度图（红外）
    std::vector<int>   label_map;       // 目标标签图
    
    // 统计信息
    float total_render_time_ms;
    float avg_rays_per_pixel;
    float convergence_error;
    
    // 序列化到文件
    bool saveToFile(const std::string& path) const;
    static SolverResult loadFromFile(const std::string& path);
};

存储格式选择：

研究/调试阶段：推荐使用HDF5或NetCDF格式，支持多维数组、元数据、多通道存储
工程化阶段：可以自定义二进制格式，配合JSON/YAML元数据文件
图像输出：最终的可视化图像可以导出为PNG/TIFF等格式，辐射数据则保留原始格式

10.6 架构师视角：不同求解方法的精度-效率权衡矩阵

在光电仿真引擎的架构设计中，选择合适的求解方法是一个典型的多目标优化问题。我们需要在精度、效率、适用范围 、实现复杂度之间做出权衡。

下表给出了四种主要求解方法的权衡矩阵：

维度	光线追踪	蒙特卡洛	离散纵标 ( $SN S_N$ SN)	有限体积
计算精度	中-高（取决于采样数）	高（样本足够时无偏）	中-高（取决于离散阶数）	中（受网格和角度离散限制）
计算效率	高（成像场景）	低（收敛慢）	很高（1D/2D问题）	中
几何适应性	极好（任意几何）	极好（任意几何）	差（规则网格）	中（非结构化网格）
参与介质	弱（单次散射尚可）	极强（多次散射）	强（分层介质）	强
噪声特性	低（确定性）	高（随机噪声）	无（有射线效应）	低
实现复杂度	中	中-高	高	很高
并行化难度	低（像素级并行）	极低（光子级并行）	中	高
内存占用	低-中	低	中-高	高

针对光电仿真场景的具体建议

场景1：远距离目标成像（大气传输为主）

推荐方法：光线追踪 + 大气传输预计算（MODTRAN/LBLRTM等）
理由：远距离成像中，目标在视场中占比小，大气路径是主要传输过程。光线追踪负责几何成像，大气传输用预计算的透射率表查询，效率极高。
精度控制：通过增加光谱采样点数和大气分层数提高精度。

场景2：近距红外场景（热辐射 + 表面反射）

推荐方法：反向路径追踪 + 直接光照采样
理由：红外场景中，目标自身热辐射是重要辐射源，同时环境反射也不可忽略。路径追踪可以自然处理二者的耦合。
优化点：对热辐射源采用重要性采样，减少漫反射路径追踪深度。

场景3：云雾/烟尘中的目标探测（强散射介质）

推荐方法：蒙特卡洛法（光子追踪）或离散纵标法
理由：强散射介质中，光线经过多次散射后方向完全随机化，光线追踪效率极低。蒙特卡洛方法可以精确模拟多次散射过程。
工程策略：对于云雾层，可以用蒙特卡洛预计算点扩散函数（PSF），然后在成像仿真中作为卷积核使用，兼顾精度与效率。

场景4：尾焰/羽流仿真（非均匀参与介质）

推荐方法：有限体积法 + CFD耦合或蒙特卡洛法
理由：尾焰温度和组分分布复杂，需要与CFD数据耦合。有限体积法可以直接使用CFD网格，蒙特卡洛法则可以处理任意复杂的分布。
工程策略：先用CFD计算流场，再用蒙特卡洛或有限体积法计算辐射传输，最后通过光线追踪生成探测器图像。

架构层面的策略：可插拔求解器

一个成熟的光电仿真引擎不应该绑定到单一求解方法。更优的架构是采用可插拔求解器设计：

scss 复制代码

┌─────────────────────────────────────────────────┐
│              Radiation Solver Interface         │
├─────────────────────────────────────────────────┤
│  solve(scene, params) -> Result                 │
│  setProgressCallback(callback)                  │
└──────────────┬──────────────┬──────────────────┘
               │              │
    ┌──────────▼─────┐  ┌─────▼──────────┐
    │ Ray Tracing    │  │ Monte Carlo    │
    │ Solver         │  │ Solver         │
    └────────────────┘  └────────────────┘
               │              │
    ┌──────────▼─────┐  ┌─────▼──────────┐
    │ Discrete       │  │ Finite Volume  │
    │ Ordinates (SN) │  │ Solver         │
    └────────────────┘  └────────────────┘

所有求解器实现统一的接口，上层模块（如渲染管线、仿真调度器）只依赖接口，不依赖具体实现。这样做的好处是：

灵活性：可以根据场景特点选择最合适的求解器
可扩展性：新增求解方法不需要修改上层代码
可对比性：可以用不同求解器计算同一问题，交叉验证精度

架构师忠告：不要试图用一个求解器解决所有问题。正确的做法是：识别80%的典型场景，用最高效的求解器处理；对剩余20%的特殊场景，提供更精确但更慢的求解器作为可选方案。在架构设计中，统一的接口和明确的适用边界，比单一方法的极致优化更有价值。

第11章可见光渲染路径

可见光仿真是光电仿真中与计算机图形学最接近的领域，但二者的目标有着本质区别：图形学追求"视觉上可信"，而光电仿真追求"物理上准确"。本章将深入探讨可见光仿真路径的架构设计，从光照模型、光线追踪加速、采样策略到光谱渲染，逐一剖析关键技术的原理与实现权衡。

11.1 可见光仿真的特点：以反射/散射为主，自发光为辅

可见光波段（约0.38~0.78μm）的仿真有以下鲜明特点：

1. 外部光源主导，自发光可忽略

在常温下（300K左右），物体的热辐射峰值在约10μm的远红外波段，可见光波段的发射几乎为零。根据维恩位移定律：

$λmax =bT,b=2898 μ m\cdotpK \lambda_{max} = \frac{b}{T}, \quad b = 2898\ \mu\text{m·K}$ λmax=Tb,b=2898 μm\cdotpK

300K时， $λmax ≈9.7μm \lambda_{max} \approx 9.7\mu\text{m}$ λmax≈9.7μm，可见光波段的黑体辐射亮度比红外低数个数量级。因此，可见光场景中的辐射几乎全部来自外部光源（太阳、天空、人工光源等），目标表面的作用是反射和散射这些入射光。

2. 表面反射特性复杂

可见光波段，材料的光学特性（折射率、吸收率）随波长变化显著，导致了丰富的色彩现象。表面反射模型需要精确描述BRDF（双向反射分布函数）的光谱依赖性。

3. 大气散射影响显著

可见光波长短，大气分子的瑞利散射（与 $λ−4\lambda^{-4}$ λ−4成正比）和气溶胶的米氏散射对成像影响显著。蓝天、晚霞、雾霾等现象都是大气散射的结果。在远距离可见光仿真中，大气散射是必须考虑的因素。

4. 人眼/探测器的光谱响应

可见光仿真的最终输出需要考虑人眼的明视觉光谱响应函数（CIE 1924 V(λ)）或探测器的光谱响应。这意味着光谱计算的结果需要通过响应函数积分得到最终的亮度值或RGB值。

这些特点决定了可见光仿真路径的架构重心：光源建模、BRDF精确描述、大气散射计算、高效的全局光照求解。

11.2 光照模型：直接光照、间接光照、环境光照

可见光渲染中的光照通常分解为三个分量：直接光照、间接光照和环境光照。这种分解不仅是物理上的，更是算法和架构上的------不同分量有不同的求解策略。

11.2.1 直接光照（Direct Illumination）

直接光照是指从光源发出、经过一次（或零次）反射到达探测器的光线。直接光照是场景中最主要的光照来源，通常占总能量的70%~90%。

直接光照的计算公式为：

$Lo(x,ωo)= ∫ Alight fr(x,ωi,ωo)Li(x,ωi)∣cos⁡θi∣V(x,x′) cos⁡θ′∣x−x′∣2 dA′ L_o(\mathbf{x}, \omega_o) = \int_{A_{light}} f_r(\mathbf{x}, \omega_i, \omega_o) L_i(\mathbf{x}, \omega_i) |\cos\theta_i| V(\mathbf{x}, \mathbf{x}') \frac{\cos\theta'}{|\mathbf{x} - \mathbf{x}'|^2} dA'$ Lo(x,ωo)=∫Alightfr(x,ωi,ωo)Li(x,ωi)∣cosθi∣V(x,x′)∣x−x′∣2cosθ′dA′

其中：

$fr f_r$ fr 是BRDF
$Li L_i$ Li 是光源的出射辐射亮度
$V(x,x′)V(\mathbf{x}, \mathbf{x}')$ V(x,x′) 是可见性函数（1表示可见，0表示遮挡）
$cos⁡θi \cos\theta_i$ cosθi 和 $cos⁡θ′\cos\theta'$ cosθ′ 分别是入射方向与表面法线、光源法线的夹角
最后一项是几何项（面积元到立体角的转换）

在工程实现中，直接光照通常采用对光源采样的策略：对每个光源，从着色点向光源采样一个方向，检测是否被遮挡，然后计算贡献。

cpp 复制代码

// 直接光照计算：对光源采样
Spectrum evaluateDirectLighting(
    const SurfaceHit& hit, const Vector3& wo,
    const Scene& scene, Sampler& sampler) {
    
    Spectrum L_direct(0.0f);
    
    for (const auto& light : scene.lights()) {
        // 1. 从光源采样一个入射方向
        Vector3 wi;
        float pdf;
        float dist;
        Spectrum Li = light->sampleLe(hit.point, wi, pdf, dist, sampler);
        
        if (pdf <= 0.0f || Li.isBlack()) continue;
        
        // 2. 检测阴影
        if (scene.isOccluded(hit.point, wi, dist)) continue;
        
        // 3. 计算BRDF值
        Spectrum f = hit.material->evaluateBRDF(hit.normal, wo, wi);
        if (f.isBlack()) continue;
        
        // 4. 余弦项
        float cosThetaI = std::abs(dot(hit.normal, wi));
        
        // 5. 累加贡献
        L_direct += f * Li * cosThetaI / pdf;
    }
    
    return L_direct;
}

11.2.2 间接光照（Indirect Illumination）

间接光照是指经过两次及以上反射到达探测器的光线。间接光照贡献了场景中的柔和阴影、颜色渗透（Color Bleeding）等效果。

间接光照的求解是全局光照（Global Illumination）的核心难题。由于路径空间巨大，直接穷举是不可能的。蒙特卡洛路径追踪是目前最通用的求解方法。

路径追踪的核心是渲染方程（Rendering Equation）：

$Lo(x,ωo)=Le(x,ωo)+∫Ωfr(x,ωi,ωo)Li(x,ωi)∣cos⁡θi∣dωi L_o(\mathbf{x}, \omega_o) = L_e(\mathbf{x}, \omega_o) + \int_{\Omega} f_r(\mathbf{x}, \omega_i, \omega_o) L_i(\mathbf{x}, \omega_i) |\cos\theta_i| d\omega_i$ Lo(x,ωo)=Le(x,ωo)+∫Ωfr(x,ωi,ωo)Li(x,ωi)∣cosθi∣dωi

其中 $Li(x,ωi) L_i(\mathbf{x}, \omega_i)$ Li(x,ωi) 本身又满足渲染方程（在入射点处），形成递归关系。

路径追踪通过随机采样路径来估计这个积分。每一条从相机出发的路径，经过多次反射后终止于光源或逃逸出场景。

11.2.3 环境光照（Environment Lighting）

环境光照通常指来自天空、远处环境的大面积光照。在室外场景中，天空光占总入射光的30%~50%。

环境光照的建模方式主要有两种：

参数化模型：如Preetham天空模型、Hosek-Wilkie天空模型，基于太阳位置和大气参数解析计算天空的辐射亮度分布
环境贴图：使用HDR环境贴图（如IBL，Image-Based Lighting）记录环境的辐射亮度分布

在光电仿真中，参数化模型更受青睐，因为：

物理参数可控（太阳高度角、大气能见度等）
与大气传输模型一致
可以方便地调整仿真条件

cpp 复制代码

// Preetham天空模型的简化实现
class PreethamSkyModel {
public:
    PreethamSkyModel(float sunTheta, float sunPhi, float turbidity)
        : m_sunTheta(sunTheta), m_sunPhi(sunPhi), m_turbidity(turbidity) {
        computeCoefficients();
    }
    
    // 计算指定方向的天空光亮度（XYZ色彩空间）
    Vector3 getSkyRadiance(float theta, float phi) const {
        float gamma = computeSunAngle(theta, phi);
        float chi = std::acos(std::cos(theta) * std::cos(m_sunTheta) + 
                              std::sin(theta) * std::sin(m_sunTheta) * std::cos(phi - m_sunPhi));
        
        Vector3 result;
        for (int i = 0; i < 3; ++i) {
            float zenith = m_YxyZenith[i];
            float f = perezFunction(gamma, theta, m_A[i], m_B[i], m_C[i], m_D[i], m_E[i]);
            float fZ = perezFunction(m_sunTheta, 0.0f, m_A[i], m_B[i], m_C[i], m_D[i], m_E[i]);
            result[i] = zenith * f / fZ;
        }
        return result;
    }
    
private:
    float perezFunction(float gamma, float theta, float A, float B, float C, float D, float E) const {
        return (1 + A * std::exp(B / std::cos(theta))) *
               (1 + C * std::exp(D * gamma) + E * std::cos(gamma) * std::cos(gamma));
    }
    
    void computeCoefficients() {
        // 根据浊度计算Perez系数和天顶亮度
        // 具体公式参考Preetham 1999论文
        // ...
    }
    
    float m_sunTheta, m_sunPhi, m_turbidity;
    float m_A[3], m_B[3], m_C[3], m_D[3], m_E[3];
    float m_YxyZenith[3];
};

11.3 光线追踪加速：BVH遍历、SAH构建、光线包络

光线追踪的性能瓶颈在于求交测试。对于一个包含百万级三角形的场景，如果每条光线都和所有三角形求交，计算量是不可接受的。空间加速结构的作用就是将求交的时间复杂度从O(N)降低到O(log N)。

11.3.1 BVH（Bounding Volume Hierarchy）

BVH是目前光线追踪中最主流的加速结构。其基本思想是：将场景几何体组织成一棵树形结构，每个节点包含一个包围盒（Bounding Box）和若干子节点。光线与场景求交时，先与父节点的包围盒求交，如果不相交则跳过整个子树；如果相交则递归测试子节点。

BVH的核心优势：

内存紧凑：只需要存储包围盒和索引，内存开销小
构建灵活：可以根据场景特点选择不同的构建策略
遍历高效：树结构天然适合递归遍历，缓存友好

11.3.2 SAH（Surface Area Heuristic）构建

BVH的构建质量直接影响遍历效率。SAH是目前公认的最优构建启发式策略。

SAH的核心思想基于一个概率模型：光线与包围盒相交的概率与包围盒的表面积成正比。因此，最优的划分方式应该最小化预期求交代价：

$C(A,B)= Ctrav +pA⋅C(A)+pB⋅C(B)C(A, B) = C_{trav} + p_A \cdot C(A) + p_B \cdot C(B)$ C(A,B)=Ctrav+pA⋅C(A)+pB⋅C(B)

其中：

$Ctrav C_{trav}$ Ctrav 是遍历一个节点的代价（常数）
$pA p_A$ pA、 $pB p_B$ pB 是光线进入子节点A、B的概率，与表面积成正比
$C(A)C(A)$ C(A)、 $C(B)C(B)$ C(B) 是子节点内部的求交代价

对于叶节点，代价为 $Cleaf =N⋅ Cisect C_{leaf} = N \cdot C_{isect}$ Cleaf=N⋅Cisect，其中N是三角形数量， $Cisect C_{isect}$ Cisect 是单个三角形的求交代价。

cpp 复制代码

// SAH BVH构建的核心算法
struct BVHSplitCandidate {
    float cost;
    int axis;
    int splitIndex;
    BoundingBox leftBox;
    BoundingBox rightBox;
};

BVHSplitCandidate findBestSAHSplit(
    const std::vector<BVHPrimitive>& primitives,
    int start, int end, const BoundingBox& nodeBox) {
    
    BVHSplitCandidate best;
    best.cost = std::numeric_limits<float>::max();
    
    const int BIN_COUNT = 16;  // 分箱数，精度与效率的权衡
    
    // 在三个轴上分别尝试
    for (int axis = 0; axis < 3; ++axis) {
        // 1. 将图元按中心位置分到各个箱子
        std::vector<BoundingBox> binBoxes(BIN_COUNT);
        std::vector<int> binCounts(BIN_COUNT, 0);
        
        float minBound = nodeBox.min()[axis];
        float maxBound = nodeBox.max()[axis];
        float binSize = (maxBound - minBound) / BIN_COUNT;
        
        if (binSize < 1e-6f) continue;
        
        for (int i = start; i < end; ++i) {
            float center = primitives[i].center[axis];
            int binIdx = std::min(BIN_COUNT - 1, 
                (int)((center - minBound) / binSize));
            binBoxes[binIdx].expand(primitives[i].box);
            binCounts[binIdx]++;
        }
        
        // 2. 前缀和：从左到右累计包围盒和数量
        std::vector<BoundingBox> leftSweep(BIN_COUNT);
        std::vector<int> leftCounts(BIN_COUNT, 0);
        leftSweep[0] = binBoxes[0];
        leftCounts[0] = binCounts[0];
        for (int i = 1; i < BIN_COUNT; ++i) {
            leftSweep[i] = BoundingBox::merge(leftSweep[i-1], binBoxes[i]);
            leftCounts[i] = leftCounts[i-1] + binCounts[i];
        }
        
        // 3. 后缀和：从右到左
        std::vector<BoundingBox> rightSweep(BIN_COUNT);
        std::vector<int> rightCounts(BIN_COUNT, 0);
        rightSweep[BIN_COUNT-1] = binBoxes[BIN_COUNT-1];
        rightCounts[BIN_COUNT-1] = binCounts[BIN_COUNT-1];
        for (int i = BIN_COUNT - 2; i >= 0; --i) {
            rightSweep[i] = BoundingBox::merge(rightSweep[i+1], binBoxes[i]);
            rightCounts[i] = rightCounts[i+1] + binCounts[i];
        }
        
        // 4. 计算每个划分位置的SAH代价
        float totalArea = nodeBox.surfaceArea();
        for (int i = 0; i < BIN_COUNT - 1; ++i) {
            float leftArea = leftSweep[i].surfaceArea();
            float rightArea = rightSweep[i+1].surfaceArea();
            
            // SAH代价公式
            float cost = TRAVERSAL_COST +
                (leftCounts[i] * leftArea + rightCounts[i+1] * rightArea) 
                * INTERSECTION_COST / totalArea;
            
            if (cost < best.cost) {
                best.cost = cost;
                best.axis = axis;
                best.splitIndex = i;
                best.leftBox = leftSweep[i];
                best.rightBox = rightSweep[i+1];
            }
        }
    }
    
    return best;
}

架构师视角的SAH权衡：

分箱数（BIN_COUNT）：分箱数越多，划分越精细，构建质量越高，但构建时间越长。16~32是常用的工程折中。
叶节点大小：叶节点包含的三角形数影响遍历效率。太小则树太深、遍历开销大；太大则叶内求交多。通常设为2~4个三角形。
构建时间 vs 遍历时间：SAH构建是O(N log N)，但常数因子大。对于静态场景，构建一次即可；对于动态场景，可能需要使用更快的构建策略（如中位划分、LBVH）。

11.3.3 光线包络（Ray Packet）与SIMD优化

为了进一步提升光线追踪的性能，工业级渲染器通常使用光线包络技术：将多条光线打包，同时与BVH节点求交，利用SIMD指令并行计算。

核心思想：

将8条、16条甚至更多光线组成一个"包"（Packet）
光线包与包围盒求交时，使用SIMD指令同时计算多条光线
如果整个包都不与某个节点相交，则整组跳过

cpp 复制代码

// 8-wide SIMD光线-盒子求交（概念示例）
__m256 intersectBoxSIMD(
    const BVHNode& node,
    const __m256& rayOx, const __m256& rayOy, const __m256& rayOz,
    const __m256& invDx, const __m256& invDy, const __m256& invDz,
    const __m256& tNear, const __m256& tFar) {
    
    // x面
    __m256 tx1 = _mm256_mul_ps(_mm256_sub_ps(_mm256_set1_ps(node.boxMin.x), rayOx), invDx);
    __m256 tx2 = _mm256_mul_ps(_mm256_sub_ps(_mm256_set1_ps(node.boxMax.x), rayOx), invDx);
    __m256 tminX = _mm256_min_ps(tx1, tx2);
    __m256 tmaxX = _mm256_max_ps(tx1, tx2);
    
    // y面、z面同理
    // ...
    
    // 合并
    __m256 tmin = _mm256_max_ps(tminX, _mm256_max_ps(tminY, tminZ));
    __m256 tmax = _mm256_min_ps(tmaxX, _mm256_min_ps(tmaxY, tmaxZ));
    
    // 返回相交掩码：tmax >= max(tmin, tNear)
    __m256 tminClamped = _mm256_max_ps(tmin, tNear);
    __m256 mask = _mm256_cmp_ps(tmax, tminClamped, _CMP_GE_OQ);
    return mask;
}

设计权衡：

包大小：包越大，SIMD利用率越高，但光线发散（如打到不同物体）时浪费也越严重。8-wide是常见的平衡点。
一致性：光线包的效率依赖于光线方向的一致性。主光线（Primary Ray）方向一致，包效率高；次级反射光线方向发散，包效率低。
架构复杂度：SIMD光线追踪的代码复杂度远高于标量版本。是否引入需要评估性能收益是否值得额外的开发和维护成本。

11.4 采样策略：重要性采样、多重重要性采样

路径追踪的收敛速度与采样策略密切相关。好的采样策略可以用更少的样本达到相同的收敛效果。

11.4.1 重要性采样（Importance Sampling）

重要性采样的核心思想是：按照被积函数的形状来采样------函数值大的地方多采样，函数值小的地方少采样。这样可以减小估计的方差。

对于积分 $I=∫f(x)dxI = \int f(x) dx$ I=∫f(x)dx，如果我们按照概率密度函数 $p(x)p(x)$ p(x) 采样，估计量为 $f(x)/p(x)f(x)/p(x)$ f(x)/p(x)。当 $p(x)∝f(x)p(x) \propto f(x)$ p(x)∝f(x) 时，方差为零（常数估计量）。

在路径追踪中，有两个常用的重要性采样方向：

BRDF重要性采样：按照BRDF的形状采样反射方向
光源重要性采样：按照光源的形状和亮度采样光源方向

以Phong BRDF的重要性采样为例：

cpp 复制代码

// Phong BRDF的重要性采样
// f(wi, wo) = (n+2)/(2pi) * cos^n(alpha) * cos(theta_i)
// 其中 alpha 是反射方向与理想镜面反射方向的夹角
Vector3 samplePhongBRDF(
    const Vector3& wo, const Vector3& normal, 
    float n, float& pdf) {
    
    // 1. 在镜面反射方向周围采样
    Vector3 R = reflect(-wo, normal);  // 理想镜面反射方向
    
    // 2. 生成cos^n分布的方向（在R的局部坐标系中）
    float xi1 = rand01();
    float xi2 = rand01();
    
    float cosTheta = std::pow(xi1, 1.0f / (n + 1));
    float sinTheta = std::sqrt(1.0f - cosTheta * cosTheta);
    float phi = 2.0f * M_PI * xi2;
    
    // 在局部坐标系（以R为z轴）中
    Vector3 localDir(
        sinTheta * std::cos(phi),
        sinTheta * std::sin(phi),
        cosTheta
    );
    
    // 3. 变换到世界坐标系
    Vector3 tangent, bitangent;
    buildOrthonormalBasis(R, tangent, bitangent);
    Vector3 wi = localDir.x * tangent + localDir.y * bitangent + localDir.z * R;
    wi.normalize();
    
    // 4. 计算PDF
    pdf = (n + 1) / (2.0f * M_PI) * std::pow(cosTheta, n);
    
    return wi;
}

11.4.2 多重重要性采样（Multiple Importance Sampling, MIS）

当被积函数由多个因素共同决定时（如BRDF × 光照分布），单独对某一个因素采样可能效果不好。多重重要性采样的思想是：同时使用多种采样策略，然后用加权的方式合并结果。

MIS的加权公式（平衡启发式，Balance Heuristic）：
$wi(x)= nipi(x) ∑jnjpj(x) w_i(x) = \frac{n_i p_i(x)}{\sum_j n_j p_j(x)}$ wi(x)=∑jnjpj(x)nipi(x)

其中 $ni n_i$ ni 是第i种策略的采样数， $pi(x) p_i(x)$ pi(x) 是第i种策略在点x处的概率密度。

功率启发式（Power Heuristic）效果更好，是更常用的选择：
$wi(x)= (nipi(x))β ∑j(njpj(x))β w_i(x) = \frac{(n_i p_i(x))^\beta}{\sum_j (n_j p_j(x))^\beta}$ wi(x)=∑j(njpj(x))β(nipi(x))β

通常取 $β=2\beta = 2$ β=2。

在路径追踪中，MIS主要用于直接光照计算：同时对BRDF采样和对光源采样，然后用MIS加权合并。

cpp 复制代码

// 使用MIS的直接光照计算
Spectrum evaluateDirectLightingMIS(
    const SurfaceHit& hit, const Vector3& wo,
    const Scene& scene, Sampler& sampler) {
    
    Spectrum L_direct(0.0f);
    
    for (const auto& light : scene.lights()) {
        // === 策略1：对光源采样 ===
        {
            Vector3 wi;
            float pdfLight;
            float dist;
            Spectrum Li = light->sampleLe(hit.point, wi, pdfLight, dist, sampler);
            
            if (pdfLight > 0.0f && !Li.isBlack() && 
                !scene.isOccluded(hit.point, wi, dist)) {
                
                Spectrum f = hit.material->evaluateBRDF(hit.normal, wo, wi);
                float cosThetaI = std::abs(dot(hit.normal, wi));
                float pdfBRDF = hit.material->evaluatePDF(hit.normal, wo, wi);
                
                // MIS权重（功率启发式，beta=2）
                float weight = powerHeuristic(1, pdfLight, 1, pdfBRDF);
                
                L_direct += f * Li * cosThetaI * weight / pdfLight;
            }
        }
        
        // === 策略2：对BRDF采样 ===
        {
            Vector3 wi;
            float pdfBRDF;
            Spectrum f = hit.material->sampleBRDF(hit.normal, wo, wi, pdfBRDF, sampler);
            
            if (pdfBRDF > 0.0f && !f.isBlack()) {
                float cosThetaI = std::abs(dot(hit.normal, wi));
                
                // 检测这条光线是否打到光源
                LightHit lightHit;
                if (light->intersectRay(hit.point, wi, lightHit)) {
                    Spectrum Li = lightHit.radiance;
                    float pdfLight = light->evaluatePDF(hit.point, wi, lightHit.dist);
                    
                    // MIS权重
                    float weight = powerHeuristic(1, pdfBRDF, 1, pdfLight);
                    
                    L_direct += f * Li * cosThetaI * weight / pdfBRDF;
                }
            }
        }
    }
    
    return L_direct;
}

// 功率启发式权重计算
float powerHeuristic(int nf, float fPdf, int ng, float gPdf) {
    float f = nf * fPdf;
    float g = ng * gPdf;
    return (f * f) / (f * f + g * g);
}

架构师视角：MIS带来的收益是显著的------在大部分场景下，MIS可以将收敛速度提升数倍甚至一个数量级。但它也带来了额外的复杂度：

BRDF需要同时提供evaluate、sample、evaluatePDF三个接口
光源也需要提供对应的采样和PDF计算接口
代码路径变长，调试和维护成本增加

对于光电仿真引擎来说，MIS是强烈建议引入的优化。因为光电仿真对精度要求高，而MIS直接降低了达到目标精度所需的样本数，从而显著减少总计算时间。

11.5 光谱渲染：RGB vs 光谱采样的对比与实现

可见光渲染的一个核心问题是：应该用RGB三通道还是用全光谱来表示颜色？

11.5.1 RGB渲染的局限

传统的RGB渲染（sRGB或Rec. 709）在计算机图形学中占据主导地位，但在光电仿真中有明显的局限：

光谱精度不足：RGB三通道只能近似人眼感知，无法精确表示任意光谱分布。不同的光谱分布可能有相同的RGB值（同色异谱，Metamerism），但经过光学系统后的表现可能不同。
色散无法模拟：不同波长的折射率不同（色散），RGB渲染无法精确模拟棱镜分光、镜头色差等现象。
与物理模型对接困难：大气传输、材质反射率等物理模型都是波长的函数，需要先转换到RGB才能使用，引入转换误差。

11.5.2 光谱渲染的优势与挑战

光谱渲染用多个波长采样点（如8~32个）来表示辐射亮度，可以更精确地模拟光学现象。

光谱渲染的优势：

物理精度高：直接使用光谱数据，避免RGB转换的误差
可模拟色散：不同波长独立追踪，可以模拟棱镜、透镜色差等
与物理模型无缝对接：大气传输、材质光谱直接查询使用
输出灵活：可以后处理为任意色彩空间（sRGB、XYZ等）

挑战：

计算量大：每个波长独立追踪，计算量与通道数成正比
内存占用高：图像数据从3通道变为N通道
材质数据要求高：需要光谱BRDF数据，而非简单的RGB反照率

11.5.3 架构设计：多波段光谱采样的实现

在光电仿真引擎中，推荐采用可配置光谱采样的架构：

cpp 复制代码

// 光谱采样配置
struct SpectrumConfig {
    float wavelength_min = 0.38f;  // μm
    float wavelength_max = 0.78f;  // μm
    int num_bands = 8;             // 采样波段数
    
    // 采样方式
    enum class SamplingMode {
        UNIFORM,        // 均匀采样
        HUMAN_EYE_WEIGHTED,  // 人眼响应加权采样
        CUSTOM          // 自定义
    };
    SamplingMode mode = SamplingMode::UNIFORM;
    
    // 获取第i个波段的中心波长
    float wavelength(int i) const {
        // 根据采样模式计算
        // ...
    }
};

// 光谱值类：固定大小数组，支持SIMD操作
template<int N>
class Spectrum {
public:
    Spectrum() {
        std::fill(m_values, m_values + N, 0.0f);
    }
    
    explicit Spectrum(float v) {
        std::fill(m_values, m_values + N, v);
    }
    
    // 算术运算
    Spectrum operator+(const Spectrum& other) const {
        Spectrum result;
        for (int i = 0; i < N; ++i) result.m_values[i] = m_values[i] + other.m_values[i];
        return result;
    }
    
    Spectrum operator*(const Spectrum& other) const {
        Spectrum result;
        for (int i = 0; i < N; ++i) result.m_values[i] = m_values[i] * other.m_values[i];
        return result;
    }
    
    // 更多运算符...
    
    // 转换为sRGB
    Vector3 toSRGB(const SpectrumConfig& config) const {
        // 通过CIE XYZ色匹配函数积分
        float X = 0, Y = 0, Z = 0;
        for (int i = 0; i < N; ++i) {
            float lambda = config.wavelength(i);
            float dLambda = config.bandwidth(i);
            X += m_values[i] * CIE_x(lambda) * dLambda;
            Y += m_values[i] * CIE_y(lambda) * dLambda;
            Z += m_values[i] * CIE_z(lambda) * dLambda;
        }
        return XYZtoSRGB(Vector3(X, Y, Z));
    }
    
private:
    float m_values[N];
};

架构师的权衡建议：

方案	精度	计算量	内存	适用场景
RGB（3通道）	低	1x	1x	快速预览、对精度要求不高的场景
8通道光谱	中	~2.7x	~2.7x	大多数工程应用，精度与效率的良好平衡
16通道光谱	高	~5.3x	~5.3x	高精度要求的场景，如色差分析
32+通道光谱	很高	~10x+	~10x+	研究用途，极端精度要求

对于大多数光电仿真应用，8通道均匀采样是一个很好的起点。如果后续需要更高精度，可以增加通道数，代码架构不需要改变。

另外，一个重要的优化是：并非所有计算都需要全光谱。例如，阴影检测只需要几何信息，与波长无关，可以只执行一次；而BRDF评估、大气透射率等与波长相关的计算才需要逐通道执行。这种"共享标量计算，分离光谱计算"的策略可以显著减少光谱渲染的额外开销。

11.6 架构设计：可见光与红外的代码复用与差异处理

在多波段光电仿真引擎中，可见光和红外共享大量基础设施（场景管理、求交加速、材质系统框架等），但在物理模型和求解策略上有显著差异。如何设计架构，使得二者既能最大化复用，又能清晰地处理差异，是架构设计的关键问题。

11.6.1 复用与差异分析

可以复用的部分（约占代码量的60%~70%）：

几何系统：场景图、BVH、三角形求交
数学库：向量、矩阵、随机数生成
材质系统框架：BSDF接口、纹理采样机制
渲染管线框架：像素遍历、进度管理、结果输出
探测器几何：针孔相机、透镜系统模型

有差异的部分：

光源模型：可见光以太阳/天空/人工光源为主；红外以热辐射为主
表面交互：可见光关注BRDF（反射）；红外同时关注BRDF和发射率
大气传输：可见光关注散射；红外关注吸收和热发射
采样策略：可见光强调BRDF重要性采样；红外强调热光源采样
输出映射：可见光映射到sRGB/XYZ；红外映射到温度或辐射亮度

11.6.2 策略模式 + 模板化的组合架构

推荐的架构方案是**策略模式（运行时可切换）+ 模板化（编译时优化）**的组合：

scss 复制代码

┌─────────────────────────────────────────────────────┐
│            Render Pipeline (Template)               │
│  ┌───────────────────────────────────────────────┐  │
│  │  Pixel Loop (shared)                          │  │
│  │    for each pixel:                            │  │
│  │      ray = generateRay(pixel)                 │  │
│  │      L = traceRay(ray, strategy)              │  │
│  │      outputPixel(pixel, L)                    │  │
│  └───────────────────────────────────────────────┘  │
└──────────────┬───────────────────┬──────────────────┘
               │                   │
     ┌─────────▼────────┐ ┌────────▼──────────┐
     │ Visible Strategy │ │ Infrared Strategy │
     │  - Sun/Sky light │ │  - Thermal emit   │
     │  - BRDF sample   │ │  - Emission+BRDF  │
     │  - Atm scatter   │ │  - Atm absorb+em  │
     └──────────────────┘ └───────────────────┘

核心渲染管线以模板类实现，通过策略参数（Strategy）注入波段相关的行为。策略类实现统一的接口，包含以下方法：

cpp 复制代码

// 渲染策略接口
class IRenderStrategy {
public:
    virtual ~IRenderStrategy() = default;
    
    // 评估直接光照
    virtual Spectrum evalDirectLight(const SurfaceHit& hit, 
                                      const Vector3& wo,
                                      const Scene& scene,
                                      Sampler& sampler) const = 0;
    
    // 采样间接光照方向
    virtual Spectrum sampleIndirect(const SurfaceHit& hit,
                                     const Vector3& wo,
                                     Vector3& wi,
                                     float& pdf,
                                     Sampler& sampler) const = 0;
    
    // 评估自发光
    virtual Spectrum evalEmission(const SurfaceHit& hit,
                                   const Vector3& wo) const = 0;
    
    // 评估大气透射率
    virtual Spectrum evalAtmTransmittance(
        const Vector3& p1, const Vector3& p2) const = 0;
};

为什么用模板而非虚函数？

性能：虚函数调用在最内层循环（每条光线、每次反射）中开销不可忽视
内联优化：模板可以让编译器内联策略方法，生成更高效的代码
编译期多态：策略的选择通常在编译期或场景加载时确定，不需要运行时动态切换

为什么还需要接口类？

配置灵活性：在引擎初始化阶段，可以通过工厂模式根据配置创建具体策略
单元测试：接口便于Mock和单元测试
扩展性：新增策略只需实现接口，不影响其他代码

实际架构中，通常是双层设计：

上层：通过工厂模式创建策略对象（运行时多态）
下层：渲染管线以策略类为模板参数（编译期多态）

cpp 复制代码

// 工厂创建策略
std::unique_ptr<IRenderStrategy> createRenderStrategy(BandType band) {
    switch (band) {
        case BandType::VISIBLE:  return std::make_unique<VisibleStrategy>();
        case BandType::MWIR:     return std::make_unique<InfraredStrategy>(BandType::MWIR);
        case BandType::LWIR:     return std::make_unique<InfraredStrategy>(BandType::LWIR);
        default: throw std::invalid_argument("Unsupported band");
    }
}

// 渲染管线模板
template<typename StrategyT>
class RenderPipeline {
public:
    RenderPipeline(StrategyT strategy, const Scene& scene)
        : m_strategy(std::move(strategy)), m_scene(scene) {}
    
    void render(Image& output) {
        // 像素循环...
    }
    
private:
    StrategyT m_strategy;
    const Scene& m_scene;
};

这种设计在复用性、性能、扩展性之间取得了良好的平衡。对于架构师而言，关键的洞察是：不要试图用一套代码无差别地处理所有波段。正确的做法是识别公共内核和差异化部分，公共内核最大化复用，差异化部分通过策略模式清晰隔离。

第12章红外辐射仿真路径

红外仿真是光电仿真中最具工程价值的方向之一------从红外制导系统的算法验证，到无人机红外隐身性能评估，再到安防监控的红外成像仿真，都依赖于高精度的红外辐射仿真能力。与可见光不同，红外波段的仿真需要处理热辐射、大气吸收发射耦合、复杂目标温度分布等独特问题。本章将深入探讨红外仿真路径的架构设计，从辐射源建模、传输计算到图像生成，逐一剖析关键技术的原理与实现权衡。

12.1 红外仿真的特点：热辐射主导，自身发射不可忽略

红外波段通常分为近红外（NIR，0.75~~1.4μm）、中波红外（MWIR，3~~5μm）和长波红外（LWIR，8~14μm）。不同波段的物理特性差异显著，但与可见光相比，红外仿真有以下共性特点：

1. 目标自身热辐射是主要辐射源

常温物体（300K左右）的热辐射峰值在~10μm，正好处于长波红外波段。根据普朗克黑体辐射定律：
$Lbλ (T)= c1 λ5(e c2/(λT) −1) L_{b\lambda}(T) = \frac{c_1}{\lambda^5 \left( e^{c_2/(\lambda T)} - 1 \right)}$ Lbλ(T)=λ5(ec2/(λT)−1)c1

其中 $c1=3.7418×108 W\cdotpμm 4 /(m2⋅sr) c_1 = 3.7418 \times 10^8\ \text{W·μm}^4/(\text{m}^2·\text{sr})$ c1=3.7418×108 W\cdotpμm4/(m2⋅sr)， $c2=14388 μm\cdotpK c_2 = 14388\ \text{μm·K}$ c2=14388 μm\cdotpK。

在中波和长波红外波段，目标自身的热辐射贡献远大于对太阳辐射的反射。这意味着红外仿真的核心不是"光线从哪里来"，而是"目标自己发多少光"。

2. 目标温度分布的空间异质性

可见光仿真中，目标表面的差异主要来自材质和光照。而红外仿真中，目标表面温度的空间分布（温度场）是决定辐射分布的关键因素。同一目标，发动机蒙皮、排气口、机翼前缘、座舱等部位的温度可能相差几十甚至上百度，对应的红外辐射亮度差异可达数个数量级。

3. 大气吸收与发射耦合

在红外波段，大气不仅衰减辐射（吸收），还因为自身温度而发射辐射。比尔-朗伯定律只描述了衰减，而红外传输需要完整的发射-吸收耦合计算：
$Lλ=L0e−τ+∫0τ Lbλ (T(τ′))e−(τ−τ′)dτ′ L_\lambda = L_0 e^{-\tau} + \int_0^\tau L_{b\lambda}(T(\tau')) e^{-(\tau - \tau')} d\tau'$ Lλ=L0e−τ+∫0τLbλ(T(τ′))e−(τ−τ′)dτ′

其中第二项是大气的热发射贡献。在长波红外波段，大气自身的发射甚至可能超过目标的辐射。

4. 发射率（Emissivity）取代反照率成为关键参数

可见光中，我们关心材料的反照率（反射多少光）；红外中，我们更关心发射率（自身辐射能力）。根据基尔霍夫定律，在热平衡下，发射率等于吸收率： $ελ=αλ \varepsilon_\lambda = \alpha_\lambda$ ελ=αλ。但对于实际材料，发射率的光谱特性、角度特性都需要精确建模。

5. 特殊辐射源：尾焰、羽流、喷流

红外仿真中经常需要处理一些特殊的辐射源------飞机发动机的尾焰、导弹的羽流、舰船的烟囱喷流等。这些是高温气体辐射源，具有参与介质特性（发射、吸收、散射），其辐射计算需要结合流体力学（CFD）数据和光谱辐射特性数据库。

这些特点决定了红外仿真路径的架构重心：温度场建模、热辐射源计算、发射-吸收耦合传输、复杂目标成像。

12.2 红外辐射源建模：目标自发热、尾焰、羽流

红外场景中的辐射源远比可见光复杂。除了太阳、天空等环境源，更多的辐射来自目标自身。本节讨论三类主要的红外辐射源建模方法。

12.2.1 目标表面热辐射

目标表面的红外辐射由两部分组成：自身热发射和对环境辐射的反射。

热发射的计算公式为：
$Leλ (x,n^,θ)=ελ(x,θ)⋅ Lbλ (T(x)) L_{e\lambda}(\mathbf{x}, \hat{\mathbf{n}}, \theta) = \varepsilon_\lambda(\mathbf{x}, \theta) \cdot L_{b\lambda}(T(\mathbf{x}))$ Leλ(x,n^,θ)=ελ(x,θ)⋅Lbλ(T(x))

其中：

$ελ(x,θ) \varepsilon_\lambda(\mathbf{x}, \theta)$ ελ(x,θ) 是位置 $x\mathbf{x}$ x处、观测角 $θ\theta$ θ下的光谱发射率
$T(x)T(\mathbf{x})$ T(x) 是位置 $x\mathbf{x}$ x处的表面温度
$Lbλ (T) L_{b\lambda}(T)$ Lbλ(T) 是普朗克黑体光谱辐射亮度

环境反射的计算公式为：
$Lrλ (x,n^,θo)=∫Ωfr(x,θi,θo) Liλ (θi)cos⁡θidωi L_{r\lambda}(\mathbf{x}, \hat{\mathbf{n}}, \theta_o) = \int_{\Omega} f_r(\mathbf{x}, \theta_i, \theta_o) L_{i\lambda}(\theta_i) \cos\theta_i d\omega_i$ Lrλ(x,n^,θo)=∫Ωfr(x,θi,θo)Liλ(θi)cosθidωi

其中 $Liλ L_{i\lambda}$ Liλ 是来自环境（天空、地面、太阳等）的入射辐射。

在工程实现中，表面热辐射的计算通常集成在材质系统中：

cpp 复制代码

// 红外材质：发射率 + BRDF
class InfraredMaterial : public Material {
public:
    // 计算出射辐射亮度（发射 + 反射环境）
    Spectrum evalExitantRadiance(
        const SurfaceHit& hit,
        const Vector3& wo,
        const EnvironmentIR& env) const override {
        
        Spectrum L(0.0f);
        
        // 1. 自身热发射
        float temperature = hit.temperature;
        Spectrum Lb = blackbodySpectrum(temperature);
        float cosThetaO = std::abs(dot(hit.normal, wo));
        Spectrum emiss = m_emissivity->evaluate(hit.uv, cosThetaO);
        L += emiss * Lb;
        
        // 2. 环境反射（半球积分）
        // 对于漫反射表面，可以简化为：反射率 * 平均环境辐照度 / pi
        Spectrum reflectivity = Spectrum(1.0f) - emiss;  // 基尔霍夫定律
        Spectrum E_env = env.getHemisphereIrradiance(hit.point, hit.normal);
        L += reflectivity * E_env / M_PI;
        
        // 3. 太阳反射（如果在中波红外，太阳反射不可忽略）
        // ... 太阳方向的镜面/漫反射计算 ...
        
        return L;
    }
    
private:
    std::shared_ptr<Texture> m_emissivity;  // 发射率纹理（光谱相关）
};

// 普朗克黑体辐射函数
Spectrum blackbodySpectrum(float T, const SpectrumConfig& config) {
    Spectrum result;
    const float c1 = 3.7418e8f;   // W·μm^4/(m^2·sr)
    const float c2 = 14388.0f;    // μm·K
    
    for (int i = 0; i < config.numBands(); ++i) {
        float lambda = config.wavelength(i);
        float lambda5 = lambda * lambda * lambda * lambda * lambda;
        float expTerm = std::exp(c2 / (lambda * T));
        result[i] = c1 / (lambda5 * (expTerm - 1.0f));
    }
    return result;
}

设计要点：

发射率的角度依赖性：发射率随观测角变化，特别是在掠射角下会显著下降。工程上常用Fresnel公式或实验测量数据来建模。
基尔霍夫定律的应用：在热平衡假设下，反射率 = 1 - 发射率（不透明表面）。这减少了需要的材质参数数量。
温度场来源：表面温度分布由热特性求解模块（见第三篇）提供。材质系统只负责查询温度并计算辐射。

12.2.2 尾焰/羽流辐射建模

尾焰和羽流是航空航天红外仿真中最具挑战性的辐射源之一。它们是高温、高速、多组分的气体参与介质，其辐射特性取决于温度、压力、组分浓度的空间分布。

尾焰辐射的物理机制：

气体分子辐射：主要是H₂O、CO₂、CO等分子的振转能级跃迁，产生离散的谱线
固体颗粒辐射：尾焰中的碳黑（Soot）颗粒产生连续的热辐射
化学发光：燃烧过程中的化学反应产生的辐射

建模方法：

工程上常用的简化方法是窄谱带模型（Narrow Band Model）：将光谱分为若干窄带（如1~10cm⁻¹宽），在每个窄带内用平均透过率描述气体的辐射特性。

更精确的方法是线-by-line计算：逐根谱线计算气体的吸收系数，但计算量极大，通常只用于基准验证。

cpp 复制代码

// 尾焰辐射体：基于CFD数据的参与介质辐射源
class PlumeRadiator {
public:
    PlumeRadiator(const std::string& cfdFilePath, 
                  const GasPropertiesDB& gasDB) {
        // 加载CFD数据：温度、压力、各组分浓度的三维分布
        loadCFDData(cfdFilePath);
        
        // 预计算各网格单元的光谱发射/吸收系数
        precomputeSpectralProperties(gasDB);
    }
    
    // 沿一条光线积分尾焰的辐射贡献
    Spectrum integrateRadiance(const Ray& ray, float maxDist) const {
        // 使用光线步进法（Ray Marching）积分
        Spectrum L(0.0f);
        Spectrum tauTotal(0.0f);
        
        const int STEPS = 64;
        float stepLen = maxDist / STEPS;
        
        for (int i = 0; i < STEPS; ++i) {
            float t = (i + 0.5f) * stepLen;
            Vector3 p = ray.o + ray.d * t;
            
            // 查询该点的温度和吸收/发射系数
            float T = getTemperature(p);
            Spectrum alpha = getAbsorptionCoeff(p, T);
            Spectrum Lb = blackbodySpectrum(T, m_spectrumConfig);
            
            // 本段的光学厚度
            Spectrum tauStep = alpha * stepLen;
            
            // 发射贡献（考虑已走过路径的衰减）
            Spectrum emission = alpha * Lb * stepLen * exp(-tauTotal);
            
            L += emission;
            tauTotal += tauStep;
        }
        
        return L;
    }
    
    // 获取透射率（用于尾焰后面的目标衰减）
    Spectrum getTransmittance(const Ray& ray, float maxDist) const {
        Spectrum tau(0.0f);
        // 沿路径积分消光系数...
        return exp(-tau);
    }
    
private:
    CFDVolumeData m_cfdData;  // CFD流场数据（三维网格）
    SpectrumConfig m_spectrumConfig;
    
    void loadCFDData(const std::string& path);
    void precomputeSpectralProperties(const GasPropertiesDB& gasDB);
    
    float getTemperature(const Vector3& p) const;
    Spectrum getAbsorptionCoeff(const Vector3& p, float T) const;
};

架构师视角的尾焰建模权衡：

方法	精度	速度	实现难度	适用场景
简化点源模型	很低	极快	低	远距离、目标占比很小
圆柱体+温度分布	低	快	低-中	概念设计、快速估算
窄谱带模型 + CFD	中-高	中	高	工程应用、大多数场景
线-by-line + LES	极高	极慢	极高	基准验证、精细分析

对于大多数工程应用，窄谱带模型 + RANS CFD 是精度和效率的良好平衡。线-by-line方法虽然精确，但计算量可能是窄谱带的100倍以上，不适合实时或大规模仿真。

12.3 红外辐射传输：发射-吸收-散射耦合计算

红外辐射在大气中的传输是一个发射、吸收、散射三者耦合的过程。与可见光主要关注散射不同，红外波段中吸收和发射占据主导地位。

12.3.1 红外大气传输的特点

红外大气传输有以下显著特点：

1. 强烈的光谱选择性

大气中的H₂O、CO₂、O₃等分子在红外波段有密集的吸收谱线，形成了所谓的"大气窗口"和"吸收带"：

3~5μm窗口（中波红外）：透射率较高，适合中距探测
8~14μm窗口（长波红外）：透射率较高，适合远距探测
2.7μm、4.3μm、6.3μm、15μm等吸收带：透射率极低，几乎无法用于探测

2. 大气自身发射不可忽略

在长波红外波段，大气温度与地面温度接近，大气的热发射贡献与目标辐射相当。在某些情况下（如仰视天空），大气的发射甚至超过目标。

3. 散射相对较弱

红外波长远大于大气分子尺寸，瑞利散射（与 $λ−4\lambda^{-4}$ λ−4成正比）可以忽略。气溶胶的米氏散射在近红外和中红外有一定影响，但在长波红外也较弱。因此，红外大气传输中，吸收和发射是主导因素，散射通常可以忽略或作为修正项。

12.3.2 路径积分的数值方法

对于红外路径积分，我们需要求解的是：
$Lλ(s)= Lλ,0 e −τλ(0,s) +∫0sαλ(s′) Lbλ (T(s′))e −τλ(s′,s) ds′ L_\lambda(s) = L_{\lambda,0} e^{-\tau_\lambda(0,s)} + \int_0^s \alpha_\lambda(s') L_{b\lambda}(T(s')) e^{-\tau_\lambda(s',s)} ds'$ Lλ(s)=Lλ,0e−τλ(0,s)+∫0sαλ(s′)Lbλ(T(s′))e−τλ(s′,s)ds′

其中 $τλ(s′,s)=∫s′sβλ(s′′)ds′′ \tau_\lambda(s',s) = \int_{s'}^s \beta_\lambda(s'') ds''$ τλ(s′,s)=∫s′sβλ(s′′)ds′′ 是从 $s′s'$ s′到 $ss$ s的光学厚度。

这个积分的数值求解有多种方法，各有优劣：

方法1：指数积分法（Exponential Integral）

将路径分为 $NN$ N段，每段内假设温度和吸收系数均匀，则每段有解析解。从起点向终点逐段推进：
$Li+1 =Lie −βiΔsi + αiβi Lb(Ti)(1−e −βiΔsi ) L_{i+1} = L_i e^{-\beta_i \Delta s_i} + \frac{\alpha_i}{\beta_i} L_{b}(T_i) \left(1 - e^{-\beta_i \Delta s_i}\right)$ Li+1=Lie−βiΔsi+βiαiLb(Ti)(1−e−βiΔsi)

这是最常用的方法，实现简单，精度可控。

方法2：离散纵标法（ $SN S_N$ SN）

对于一维大气问题， $SN S_N$ SN方法可以同时计算所有方向的辐射亮度分布，效率极高。但对于复杂的三维场景， $SN S_N$ SN方法的适用性有限。

方法3：蒙特卡洛法

对于强散射介质（如烟尘中的红外传输），蒙特卡洛方法是最准确的，但计算量也最大。

cpp 复制代码

// 红外大气路径积分：指数积分法实现
Spectrum integrateIRAtmosphere(
    const Vector3& start,       // 起点（目标端）
    const Vector3& end,         // 终点（探测器端）
    const Spectrum& L_start,    // 起点处的辐射亮度
    const AtmosphereModel& atm,
    const SpectrumConfig& config) {
    
    const int NUM_LAYERS = 20;  // 大气分层数
    
    Spectrum L = L_start;
    
    // 计算路径与各层的交点，得到段长
    std::vector<float> segmentLengths;
    computeLayerIntersections(start, end, atm, segmentLengths);
    
    // 从起点向终点逐段推进
    for (int i = 0; i < segmentLengths.size(); ++i) {
        float ds = segmentLengths[i];
        if (ds <= 0.0f) continue;
        
        // 获取本段的大气参数（取层中点）
        float midAlt = getMidAltitude(start, end, i, atm);
        float T = atm.getTemperature(midAlt);
        Spectrum alpha = atm.getAbsorptionSpectrum(midAlt, config);
        Spectrum beta = atm.getExtinctionSpectrum(midAlt, config);  // alpha + sigma
        Spectrum Lb = blackbodySpectrum(T, config);
        
        // 本段光学厚度
        Spectrum tau = beta * ds;
        
        // 透射率
        Spectrum trans = expSpectrum(tau * -1.0f);
        
        // 本段的发射贡献
        // 公式：L_out = L_in * exp(-tau) + (alpha/beta) * Lb * (1 - exp(-tau))
        Spectrum emitRatio = safeDivide(alpha, beta);  // 避免除零
        Spectrum emission = emitRatio * Lb * (Spectrum(1.0f) - trans);
        
        L = L * trans + emission;
    }
    
    return L;
}

精度与效率的权衡：

分层数：分层越多精度越高，但计算量也越大。对于大多数水平/斜程路径，20~30层已经足够。
垂直廓线精度：大气温度、密度的垂直分布精度直接影响传输计算精度。使用标准大气模型（如US Standard, Midlatitude Summer/Winter）是常见做法。
光谱分辨率：红外大气传输对光谱分辨率高度敏感。使用MODTRAN等成熟模型的预计算结果，比自建简化模型更可靠。

12.3.3 与MODTRAN/LBLRTM的集成策略

对于工程级红外仿真，完全自建大气辐射传输模型既不现实也不必要。行业标准做法是与MODTRAN（Moderate resolution TRANsmission）或LBLRTM（Line-By-Line Radiative Transfer Model）集成。

集成策略：

预计算查找表（LUT）：
- 预先计算不同高度、天顶角、大气模型、能见度下的大气透射率和路径辐射
- 仿真时根据实际参数插值查询
- 优点：速度极快；缺点：占用存储空间，参数维度有限
在线调用：
- 每条光线路径实时调用MODTRAN计算
- 优点：灵活、精确；缺点：速度慢
混合策略（推荐）：
- 对主路径的大气透射率用LUT快速查询
- 对需要高精度的特殊路径（如临边观测）在线计算
- 大气向上/向下的辐射通量用预计算结果

cpp 复制代码

// 大气传输模块的接口设计
class IAtmosphericTransfer {
public:
    virtual ~IAtmosphericTransfer() = default;
    
    // 获取斜程透射率
    virtual Spectrum getTransmittance(
        float altitude1, float altitude2,
        float zenithAngle, const AtmosConditions& cond) const = 0;
    
    // 获取路径热辐射（大气自身发射）
    virtual Spectrum getPathRadiance(
        float altitude1, float altitude2,
        float zenithAngle, const AtmosConditions& cond) const = 0;
    
    // 获取水平路径的透射率和路径辐射
    virtual void getHorizontalTransfer(
        float altitude, float distance,
        const AtmosConditions& cond,
        Spectrum& transmittance, 
        Spectrum& pathRadiance) const = 0;
};

// MODTRAN LUT实现
class ModtranLUT : public IAtmosphericTransfer {
public:
    explicit ModtranLUT(const std::string& lutPath) {
        loadLUT(lutPath);  // 加载预计算的查找表
    }
    
    Spectrum getTransmittance(
        float alt1, float alt2, float zenith,
        const AtmosConditions& cond) const override {
        // 多维插值：altitude1, altitude2, zenith_angle, visibility, ...
        return m_transLUT.interpolate({alt1, alt2, zenith, cond.visibility});
    }
    
    // ... 其他方法 ...
    
private:
    MultiDimLUT<Spectrum> m_transLUT;  // 透射率LUT
    MultiDimLUT<Spectrum> m_pathRadLUT; // 路径辐射LUT
    
    void loadLUT(const std::string& path);
};

架构师忠告：不要试图重新实现MODTRAN。大气辐射传输是一个高度专业化的领域，MODTRAN经过了数十年的验证和改进，其精度和可靠性远非自研模型可比。正确的做法是：将大气传输作为一个外部依赖模块，通过清晰的接口封装，引擎内部只做查询和插值。这样既能保证精度，又能聚焦于引擎核心功能的开发。

12.4 探测点与视场：红外探测器的成像几何

红外成像的几何过程与可见光基本一致------都是通过光学系统将场景成像在探测器焦平面上。但红外探测器有其独特的几何特点需要考虑。

12.4.1 红外光学系统的几何建模

红外光学系统通常采用反射式（如牛顿式、卡塞格林式）或折反式设计，因为红外材料（如锗、硅）在可见光波段不透明，无法直接用可见光的透射式设计。

从仿真的角度，光学系统的几何建模有三种层次：

层次1：针孔相机模型

最简单的模型，所有光线都通过一个针孔
适合大视场、低精度要求的场景
计算量最小

层次2：薄透镜模型

考虑焦距、光圈、像距等基本参数
可以模拟景深、视场角等一阶光学效应
适合大多数工程应用

层次3：真实光学系统模型（光线追迹）

逐面追迹光线通过多个透镜/反射镜
可以模拟像差、畸变、渐晕等高级效应
精度最高，但计算量最大，需要Zemax/CodeV等光学设计软件的透镜数据

cpp 复制代码

// 红外光学系统模型
class OpticalSystem {
public:
    virtual ~OpticalSystem() = default;
    
    // 将物方光线转换为像方光线
    // 输入：物方光线（在物空间）
    // 输出：是否到达像面，以及在像面上的位置
    virtual bool traceRay(const Ray& objectRay, 
                          Vector2& imagePos,
                          float& pathLength,
                          Spectrum& transmittance) const = 0;
    
    // 获取有效焦距
    virtual float getEffectiveFocalLength() const = 0;
    
    // 获取视场角（度）
    virtual float getFOV() const = 0;
    
    // 获取F数
    virtual float getFNumber() const = 0;
};

// 薄透镜近似实现
class ThinLensSystem : public OpticalSystem {
public:
    ThinLensSystem(float focalLength, float fNumber, float sensorWidth)
        : m_focalLength(focalLength), 
          m_fNumber(fNumber),
          m_sensorWidth(sensorWidth) {
        m_aperture = focalLength / fNumber;
        m_fov = 2.0f * std::atan(sensorWidth / (2.0f * focalLength)) * 180.0f / M_PI;
    }
    
    bool traceRay(const Ray& objectRay, Vector2& imagePos,
                  float& pathLength, Spectrum& transmittance) const override {
        // 薄透镜公式：1/u + 1/v = 1/f
        // 物距 u，像距 v，焦距 f
        
        // 简化：假设物在无穷远，像在焦平面上
        // 像高 = f * tan(theta)
        float tanThetaX = objectRay.d.x / objectRay.d.z;
        float tanThetaY = objectRay.d.y / objectRay.d.z;
        
        imagePos.x = m_focalLength * tanThetaX;
        imagePos.y = m_focalLength * tanThetaY;
        
        // 检查是否在探测器范围内
        if (std::abs(imagePos.x) > m_sensorWidth / 2.0f ||
            std::abs(imagePos.y) > m_sensorHeight / 2.0f) {
            return false;
        }
        
        // 检查是否通过孔径（光阑）
        float pupilX = objectRay.d.x / objectRay.d.z * m_focalLength;  // 简化
        float pupilY = objectRay.d.y / objectRay.d.z * m_focalLength;
        if (pupilX*pupilX + pupilY*pupilY > (m_aperture/2)*(m_aperture/2)) {
            return false;
        }
        
        pathLength = 0.0f;  // 薄透镜近似下忽略内部路径
        transmittance = Spectrum(0.95f);  // 红外透镜透射率约95%
        return true;
    }
    
    float getEffectiveFocalLength() const override { return m_focalLength; }
    float getFOV() const override { return m_fov; }
    float getFNumber() const override { return m_fNumber; }
    
private:
    float m_focalLength;
    float m_fNumber;
    float m_aperture;
    float m_sensorWidth;
    float m_sensorHeight;
    float m_fov;
};

12.4.2 瞬时视场（IFoV）与点源探测

红外探测器的一个重要参数是瞬时视场（Instantaneous Field of View, IFoV），即单个像元对应的立体角：
$IFoV=df \text{IFoV} = \frac{d}{f}$ IFoV=fd

其中 $dd$ d 是像元尺寸， $ff$ f 是焦距。

IFoV决定了系统的空间分辨率，也决定了点源/扩展源的判定标准。当目标的张角小于IFoV时，目标表现为点源（所有辐射能量集中在一个像元内）；当目标张角大于IFoV时，目标表现为扩展源（辐射分布在多个像元上）。

这个判定在红外仿真中非常重要，因为：

点源目标的图像是系统点扩散函数（PSF）的形状
扩展源目标的图像反映了目标的温度分布和几何形状
远距离目标通常是点源，近距离目标是扩展源

在架构设计中，应该在探测器模型中统一处理点源/扩展源的过渡，而不是在渲染层分别处理。

12.5 红外图像生成：辐射亮度到灰度/伪彩色的映射

红外仿真的最终输出是红外图像。与可见光图像映射到RGB不同，红外图像的映射有其独特的方式。

12.5.1 辐射亮度到灰度的映射

红外探测器的输出通常是灰度图像，每个像素的灰度值与入射的辐射能量成正比。从物理量到数字输出的映射过程如下：
$DN=G⋅ ∫λ1λ2 Lλ⋅Rλ⋅Aopt⋅IFoV⋅tint dλ+offset+noise \text{DN} = G \cdot \int_{\lambda_1}^{\lambda_2} L_\lambda \cdot R_\lambda \cdot A_{\text{opt}} \cdot \text{IFoV} \cdot t_{\text{int}} \, d\lambda + \text{offset} + \text{noise}$ DN=G⋅∫λ1λ2Lλ⋅Rλ⋅Aopt⋅IFoV⋅tintdλ+offset+noise

其中：

$GG$ G 是探测器的增益（V/W 或 DN/W）
$Rλ R_\lambda$ Rλ 是探测器的光谱响应率
$Aopt A_{\text{opt}}$ Aopt 是光学系统的入瞳面积
$IFoV\text{IFoV}$ IFoV 是瞬时视场（立体角）
$tint t_{\text{int}}$ tint 是积分时间
$offset\text{offset}$ offset 是暗电流/偏置
$noise\text{noise}$ noise 是各类噪声（散粒噪声、热噪声、读出噪声等）

在工程实现中，这个映射过程通常在探测器模块中完成，辐射传输模块只输出物理量（辐射亮度）。

cpp 复制代码

// 红外探测器的辐射-数字转换
class InfraredDetector {
public:
    // 输入：焦平面上的光谱辐射亮度分布
    // 输出：数字图像（DN值）
    Image radianceToDN(const RadianceImage& radianceImg) const {
        int w = radianceImg.width();
        int h = radianceImg.height();
        Image output(w, h, Image::Format::UINT16);
        
        // 光学参数
        float A_opt = M_PI * (m_apertureDiameter / 2.0f) * (m_apertureDiameter / 2.0f);
        float ifov = (m_pixelSize / m_focalLength) * (m_pixelSize / m_focalLength);  // 立体角近似
        float integrationFactor = A_opt * ifov * m_integrationTime;
        
        for (int y = 0; y < h; ++y) {
            for (int x = 0; x < w; ++x) {
                // 1. 光谱积分：入射辐射功率
                const Spectrum& L = radianceImg.getPixel(x, y);
                float incidentPower = 0.0f;
                for (int i = 0; i < L.numBands(); ++i) {
                    float lambda = m_spectrumConfig.wavelength(i);
                    float dLambda = m_spectrumConfig.bandwidth(i);
                    incidentPower += L[i] * m_spectralResponse[i] * dLambda;
                }
                incidentPower *= integrationFactor;
                
                // 2. 转换为电荷（光子-电子转换）
                // 简化：假设响应率单位为 A/W
                float photocurrent = incidentPower * m_responsivity;
                float charge = photocurrent * m_integrationTime;
                
                // 3. 转换为电压
                float voltage = charge / m_nodeCapacitance;
                
                // 4. 增益放大 + AD转换
                float dn = voltage * m_gain * m_adcGain + m_offset;
                
                // 5. 添加噪声
                dn += m_noiseModel.sampleNoise(incidentPower, m_temperature);
                
                // 6. 量化和限幅
                dn = std::max(0.0f, std::min((float)(m_adcMax - 1), dn));
                
                output.setPixel(x, y, (uint16_t)std::round(dn));
            }
        }
        
        return output;
    }
    
private:
    // 光学参数
    float m_focalLength;
    float m_apertureDiameter;
    float m_pixelSize;
    
    // 探测器参数
    Spectrum m_spectralResponse;  // 光谱响应率
    float m_responsivity;         // 峰值响应率 (A/W)
    float m_integrationTime;      // 积分时间 (s)
    float m_nodeCapacitance;      // 节点电容 (F)
    float m_gain;                 // 增益 (V/V)
    float m_adcGain;              // ADC增益 (DN/V)
    float m_offset;               // 偏置 (DN)
    int   m_adcMax;               // ADC满量程
    
    // 温度
    float m_temperature;          // 探测器工作温度 (K)
    
    // 噪声模型
    NoiseModel m_noiseModel;
    
    SpectrumConfig m_spectrumConfig;
};

12.5.2 伪彩色映射

虽然红外探测器的原始输出是灰度的，但在实际应用中，人们经常使用伪彩色（Pseudo-color）来增强图像的可读性。伪彩色映射将不同的灰度值映射为不同的颜色，使得温度差异更直观。

常用的伪彩色映射方案包括：

铁红色（Ironbow）：从黑→红→橙→黄→白，是最经典的红外伪彩色
彩虹色（Rainbow）：从紫→蓝→绿→黄→红，色彩丰富但可能误导
白热/黑热（White Hot / Black Hot）：传统的灰度显示
医疗色（Medical）：常用于体温筛查

伪彩色映射是后处理步骤，不应与物理计算耦合。在架构上，它应该是图像输出模块的一个可选功能。

12.6 架构师视角：红外与可见光仿真的架构统一与分离

在多波段光电仿真引擎的架构设计中，一个核心问题是：红外与可见光应该在多大程度上共享代码？完全统一还是各自独立？

本节从架构师的角度，深入分析这个问题的各个维度。

12.6.1 统一与分离的辩证关系

为什么要统一？

降低维护成本：公共模块只需要维护一份
保证一致性：几何、坐标系、时间等基础定义统一，避免不一致的bug
便于多波段融合：统一的数据格式便于可见光/红外融合仿真
人力资源效率：开发人员只需要掌握一套代码框架

为什么要分离？

物理模型差异大：热辐射 vs 反射光，物理机制完全不同
性能优化方向不同：可见光优化全局光照、材质采样；红外优化温度场查询、大气传输
数据管线不同：可见光需要纹理、光照贴图；红外需要温度场、发射率、CFD数据
用户群体不同：可见光仿真用户和红外仿真用户的需求差异显著

架构师的核心洞察 ：完全统一和完全分离都是错误的。正确的策略是分层统一------在基础层高度统一，在物理模型层适度分离，在应用层按需组合。

12.6.2 分层架构设计

推荐的分层架构如下：

scss 复制代码

┌─────────────────────────────────────────────────────────┐
│                   Application Layer                     │
│  仿真任务调度  │  参数管理  │  结果分析  │  可视化       │
├─────────────────────────────────────────────────────────┤
│                   Rendering Layer                       │
│  ┌──────────────┐         ┌──────────────────┐         │
│  │ Visible      │         │ Infrared         │         │
│  │ Renderer     │         │ Renderer         │         │
│  └──────┬───────┘         └────────┬─────────┘         │
├─────────┼──────────────────────────┼───────────────────┤
│         │   Shared Core Layer      │                   │
│         │  - 几何系统 (BVH, 求交)  │                   │
│         │  - 材质框架 (BSDF接口)   │                   │
│         │  - 数学/光谱基础库       │                   │
│         │  - 场景管理 (场景图)      │                   │
│         │  - 并行计算框架          │                   │
│         └──────────────────────────┘                   │
├─────────────────────────────────────────────────────────┤
│                   Platform Layer                        │
│  操作系统抽象  │  硬件抽象  │  文件IO  │  网络          │
└─────────────────────────────────────────────────────────┘

各层的统一程度：

层级	统一程度	说明
平台层	100%统一	所有波段共享
核心层	90%统一	几何、数学、场景管理完全共享；材质系统框架共享，具体材质不同
渲染层	30%统一	管线框架共享，具体的光照/传输/采样策略不同
应用层	50%统一	任务调度、结果存储共享；参数配置、分析工具有差异

12.6.3 关键设计决策

决策1：材质系统的统一与分离

材质系统是可见光和红外差异最大的模块之一。建议采用统一接口 + 分层实现：

cpp 复制代码

// 统一的材质基类接口
class Material {
public:
    virtual ~Material() = default;
    
    // 评估BSDF（双向散射分布函数）
    virtual Spectrum evaluateBSDF(
        const SurfaceHit& hit,
        const Vector3& wi, const Vector3& wo) const = 0;
    
    // 采样BSDF方向
    virtual Spectrum sampleBSDF(
        const SurfaceHit& hit, const Vector3& wo,
        Vector3& wi, float& pdf, Sampler& sampler) const = 0;
    
    // 评估发射（红外中重要，可见光中通常为零）
    virtual Spectrum evaluateEmission(
        const SurfaceHit& hit, const Vector3& wo) const {
        return Spectrum(0.0f);  // 默认不发光
    }
    
    // 是否发光（用于光源判定）
    virtual bool isEmissive() const { return false; }
};

// 可见光材质：侧重BRDF和纹理
class VisibleMaterial : public Material {
    // albedo纹理、normal map、roughness、metallic...
};

// 红外材质：侧重发射率和温度
class InfraredMaterial : public Material {
    // 发射率纹理、温度场关联、BRDF简化...
    
    Spectrum evaluateEmission(...) const override {
        // 普朗克公式 + 发射率
        return m_emissivity * blackbody(m_temperature);
    }
    
    bool isEmissive() const override { return true; }
};

这样设计的好处是：渲染管线只依赖Material基类接口，可以用同一套管线处理可见光和红外材质。但具体的材质属性和行为是各自独立的。

决策2：大气传输模块的设计

大气传输是另一个差异显著的模块。建议采用同一接口，不同实现：

cpp 复制代码

// 大气传输统一接口
class IAtmosphere {
public:
    virtual ~IAtmosphere() = default;
    
    // 透射率
    virtual Spectrum getTransmittance(const Vector3& p1, const Vector3& p2) const = 0;
    
    // 路径辐射（大气自身发射）
    virtual Spectrum getPathRadiance(const Vector3& p1, const Vector3& p2) const = 0;
    
    // 天空光/天空辐射
    virtual Spectrum getSkyRadiance(const Vector3& dir, float altitude) const = 0;
};

// 可见光大气：重点是散射
class VisibleAtmosphere : public IAtmosphere {
    // 瑞利散射、米氏散射、单次散射近似...
};

// 红外大气：重点是吸收和发射
class InfraredAtmosphere : public IAtmosphere {
    // MODTRAN LUT、吸收发射耦合、大气窗口...
};

决策3：渲染管线的复用策略

渲染管线的复用是最有争议的。有两种策略：

策略A：独立管线（两套代码）

优点：各自可以深度优化，代码逻辑清晰
缺点：重复代码多，维护成本高

策略B：模板化共享管线（一套模板，两种策略）

优点：代码复用率高，一致性好
缺点：模板代码复杂，调试难度大

建议：对于中等规模的引擎（10万~50万行代码），推荐策略B。核心渲染逻辑（光线生成、求交、路径追踪框架）共享，通过策略参数注入波段相关的行为。对于超大规模引擎，可能需要策略A以获得极致的性能和灵活性。

12.6.4 架构演进路径

对于从零搭建的光电仿真引擎，建议的架构演进路径是：

阶段1：单波段起步（可见光或红外）

先实现一个波段的完整功能
建立核心基础设施（几何、材质、渲染管线）
验证整体架构的可行性

阶段2：引入第二个波段，识别公共内核

在第一个波段的基础上，添加第二个波段的支持
过程中识别哪些可以复用、哪些需要独立
重构公共模块为共享库

阶段3：抽象统一接口，建立分层架构

将公共模块抽象为统一接口
建立清晰的分层架构和模块边界
实现可配置的多波段仿真能力

阶段4：深度优化与扩展

针对各波段的特点进行深度优化
添加更多高级特性（偏振、高光谱、多传感器融合等）

这个演进路径符合"先做对，再做好"的工程原则。不要在项目初期就追求完美的统一架构------过早的抽象往往是错误的抽象。通过实际的开发过程来识别复用点，抽象出来的接口才是真正有价值的。

架构师总结：红外与可见光的架构统一，本质上是"寻找共性、尊重差异"的过程。共性的部分（几何、数学、基础框架）要坚决统一，减少重复劳动；差异的部分（物理模型、数据管线、优化策略）要清晰分离，避免过度耦合。统一和分离的边界不是固定的，而是随着项目的演进而动态调整的。好的架构不是设计出来的，而是演进出来的------架构师的职责，是在正确的时间做出正确的权衡，让架构朝着更合理的方向演进。

从零搭建光电仿真引擎（四）：光学仿真与辐射传输