20、光线传输与蒙特卡罗方法解析

光线传输与蒙特卡罗方法解析

1. 数值近似

渲染方程可以写成更紧凑的形式：
[L = L_e + TL]
其中 (T) 是在函数空间中定义的泛函：
[T(g(x, v)) = \int_{S_x} f(x, u, v) \langle u, n \rangle g(x, u) du]

为了得到方程的近似解，我们可以将 (L) 用右侧的表达式替换。例如，进行一次替换后得到：
[L = L_e + T(L_e + TL) = L_e + TL_e + T^2L]
重复这个过程 (n + 1) 次，可得：
[L = L_e + \sum_{i = 1}^{n} T^nL_e + T^{n + 1}L]
忽略 (n + 1) 阶的残差项，就得到了渲染方程的一个近似解：
[L = L_e + \sum_{i = 1}^{n} T^nL_e]

如果考虑所有的 (n \in N)，就得到了纽曼级数。从物理意义上理解，场景中某一点发出的光由该点直接射向观察者的光以及经过 1 次、2 次、3 次……反射后的光共同组成。这也是蒙特卡罗方法求解渲染方程的基础。

2. 蒙特卡罗积分方法

蒙特卡罗算法是一种利用概率过程来求积分近似解的算法。在理解该算法之前，我们需要先了解概率变量的期望值 (E[x]) 的定义。对于在集合 (\Omega) 上具有密度函数 (p(x)) 的概率变量，其期望值定义为：
[E[x] = \int_{x \in \Omega} x p(x) dx]

蒙特卡罗算法的核心思想是利用大数定律。大数定律表明，当 (n \to \infty) 时：
[E[x] \approx \frac{1}{n} \sum_{i = 1}^{n} x_i]
其中 (x_1, x_2, \cdots, x_n) 是具有密度 (p(x)) 的概率变量的样本。更精确地说，如果所有的 (x_i) 是独立同分布的随机变量，那么：
[Probability\left[E(x) = \lim_{n \to \infty} \frac{1}{n} \sum_{i = 1}^{n} x_i\right] = 1]

我们还可以定义函数 (f(x)) 的期望值：
[E[f(x)] = \int_{x \in \Omega} f(x) p(x) dx]
这意味着，如果我们想用期望值积分来近似 (\int_{x \in \Omega} f(x) dx)，可以定义一个具有概率密度 (g) 的变量：
[g(x) = \frac{f(x)}{p(x)}]
在这种情况下，当 (n \to \infty) 时：
[\int_{x \in \Omega} f(x) dx = \int_{x \in \Omega} g(x) p(x) dx = E(g(x)) \approx \frac{1}{n} \sum_{i = 1}^{n} g(x_i)]
其中 (x_1, x_2, \cdots, x_n) 是具有密度 (p(x)) 的概率变量的样本。

3. 路径追踪

考虑一个包含多个纯反射表面和一个光源的场景。路径追踪算法通过应用蒙特卡罗积分方法，并结合前面提到的数值近似方法来求解渲染方程。

如前文所述，截断纽曼级数可以得到渲染方程的近似解。级数中的每一项都是一个积分，可以使用蒙特卡罗方法求解。具体来说，为了得到像素 (p) 处渲染方程的近似样本，我们从相机中心发射一条方向对应于 (p) 的光线。每次光线与场景中的表面相交时，我们在该表面上方的半球内均匀分布地创建一条新光线。重复这个过程，直到光线与光源相交。

在每次相交处，我们应用双向反射分布函数（BRDF）来估计每个表面反射到下一个表面的光量。每条路径都为求解渲染方程的纽曼级数提供了一个近似值。通过计算同一像素处多条路径的平均值，可以提高渲染方程解的精度。

4. 半球上的均匀采样

使用条件概率过程可以很容易地在具有法向量 (n \in R^3) 的表面上方的半球上进行均匀采样。具体步骤如下：
1. 以均匀概率在立方体 ([-1, 1] \times [-1, 1] \times [-1, 1]) 内选择一个点 (x_i \in R^3)。
2. 如果 (|x_i| > 1)，则丢弃该点。
3. 如果 (\langle x_i, n \rangle > 0)，则接受 (\frac{x_i}{|x_i|}) 作为样本；否则，接受 (-\frac{x_i}{|x_i|}) 作为样本。

这个过程可以用以下 mermaid 流程图表示：

graph TD;
    A[选择立方体 [-1, 1]×[-1, 1]×[-1, 1] 内的点 xi] --> B{||xi|| > 1?};
    B -- 是 --> A;
    B -- 否 --> C{<xi, n> > 0?};
    C -- 是 --> D[接受 xi/||xi|| 作为样本];
    C -- 否 --> E[接受 -xi/||xi|| 作为样本];

5. 直接光照与间接光照分离

在前面介绍的路径追踪算法中，光线可能需要经过很长的路径才能到达光源。为了更好地近似渲染方程的解，我们可以将 3D 场景中的光照分为直接光照和间接光照两部分。

即：
[TotalRadiance = DirectRadiance + IndirectRadiance]

具体来说，在每次相交处，我们认为光来自两个不同的方向：一个是光线反射到其他表面的方向，另一个是指向光源上所选点的一组光线的方向。

需要注意的是，如果反射光线击中光源表面，应将其从场景中排除，此时认为该点的光照为零，因为直接光照是单独计算的。另外，对于完美镜面表面，只应使用间接光照模型。

计算直接光照时，我们可以使用蒙特卡罗算法，具体步骤如下：
1. 按照均匀采样过程在光源上随机选择一个点 (x’)。
2. 根据前面定义的 (V) 和 (G)，得到蒙特卡罗求和的一项：
[L(x, u, v) = \frac{f(x, u, v) L_e(x, u) V(x, x’) G(x, x’)}{p(x’)} = f(x, u, v) L_e(x, u) V(x, x’) G(x, x’) A]
其中 (A) 是光源的面积。

最终，来自光源的直接光照的近似值为：
[L(x, v) \approx \frac{1}{n} \sum_{i = 1}^{n} f(x, u_i, v) L_e(x, u_i) V(x, x’_i) G(x, x’_i) A]
其中 (x’_1, x’_2, \cdots, x’_n) 是在光源表面上均匀分布采样得到的点，(u_i \in R^3) 定义为：
[u_i = \frac{x’_i - x}{|x’_i - x|}]

6. 多边形光源

为了使用前面的公式定义多边形光源产生的直接光照，我们需要知道多边形的面积以及对该多边形进行均匀采样的方法。

由于光源在视觉效果中不常使用，我们只考虑将其分割成面积相等的三角形的情况。在这种情况下，我们可以对每个三角形进行均匀采样。

如果 (v_0, v_1, v_2) 是三角形的顶点，(r_1, r_2) 是区间 ([0, 1]) 上的两个均匀随机变量，那么可以通过以下公式得到三角形上的一个均匀随机点 ((x, y, z))：
[x = (1 - \sqrt{r_1}) v_0]
[y = \sqrt{r_1} (1 - r_2) v_1]
[z = r_2 \sqrt{r_1} v_2]

多边形的面积可以通过将各个三角形的面积相加得到，每个三角形的面积计算公式为：
[\frac{1}{2} |(v_2 - v_0) \times (v_1 - v_0)|]

7. 代码模块

7.1 路径追踪 API

以下是路径追踪相关的 API 函数：
| 函数名 | 功能 |
| ---- | ---- |
| Color trace_path( int first_level, int level, Ray v, Object *ol ); | 实现路径追踪算法的递归代码。 first_level 表示场景表面之间的反射次数， level 表示当前反射深度，每次递归减 1， v 表示当前要估计颜色的光线， ol 是场景中所有对象的列表。如果某个对象材质的 se 参数为负，则路径追踪表现为镜面反射。 |
| Color mirror_reflect( int first_level, int level, Ray v, Inode *i, Vector3 p, Object *ol, Material *m ); | 返回完美镜面方向的颜色。 first_level 、 level 、 v 和 ol 的含义与 trace_path 函数相同， i 是对应点 p 的节点， m 是点 p 处的材质。 |
| Color apply_bphong( Material *m, Color lcolor, Vector3 n, Vector3 l, Vector3 v, Real geomfactor ); | 基于 Blinn - Phong 反射模型实现 BRDF。 m 是材质描述， lcolor 是入射光的颜色， n 是表面的法向量， l 是入射光的方向， v 是观察方向， geomfactor 用于处理多边形光源或普通表面的光线反射情况。 |
| Vector3 sort_new_direction( Cone c ); | 返回在由 c 描述的半球上的均匀采样结果，实现了前面介绍的半球均匀采样算法。 |
| Bool hit_surface( Ray v, Object *ol ); | 如果光线 v 与对象列表 ol 中的对象相交，则返回 TRUE ；否则返回 FALSE 。 |
| void adjust_normal( Inode *i, Ray v ); | 使节点 i 的法向量 i->n 指向包含光线 v 的半空间。 |

7.2 路径追踪代码

以下是路径追踪的代码实现：

// extracted from ibl/ibl.h
#define REAL_RANDOM
((double)rand()/RAND_MAX)
// extracted from lptrace/ptrace.h
#ifndef PTRACE_H
#define PTRACE_H
#include <math.h>
#include "rshade.h"
#include "rt.h"
#include "ibl.h"
#include "plight.h"
#include <time.h>
#include <stdlib.h>
#include <string.h>
Color trace_path( int first_level, int level, Ray v, Object *ol );
Color mirror_reflect( int first_level, int level, Ray v, Inode *i,
Vector3 p, Object *ol, Material *m );
Color apply_bphong( Material *m, Color lcolor, Vector3 n, Vector3 l,
Vector3 v,
Real geom_fac );
Vector3 sort_new_direction( Cone c );
Bool hit_surface( Ray v, Object *ol );
void adjust_normal( Inode *i, Ray v );
#endif
// lptrace/ptrace.c
#include "ptrace.h"
static Color direct_light( int ns, Vector3 p, Vector3 n, Vector3 v,
Object *ol, PolyLight *l, Material *m );
static int light_visible(Ray r, Object *ol, PolyLight *l, Color *c );
#include "ptrace.h"
Color trace_path( int first_level, int level, Ray v, Object *ol )
{
    PolyLight *l = plight_head;
    Color c = C_BLACK, c_aux, w;
    Ray r;
    Inode *i = ray_intersect(ol, v);
    adjust_normal( i, v );
    if( light_visible(v,ol,l,&w) )
        return w;
    if((i != NULL) && level){
        level--;
        Material *m = i->m;
        Vector3 p = ray_point(v, i->t);
        Cone
        recv = cone_make(p, i->n, PIOVER2);
        if( m->se < 0 )
            c = mirror_reflect( first_level, level, v, i, p, ol, m );
        else{
            Vector3 d = sort_new_direction(recv);
            c = direct_light( DIRECT_LIGHT_NSMPLS, p, i->n,
            v3_scale(-1,v.d), ol, l, m);
            if( !light_visible(ray_make(recv.o, d), ol, l, &w) ){
                c_aux = trace_path( first_level, level, ray_make(p, d), ol );
                c = c_add(c, apply_bphong( m, c_aux, i->n,
                d, v3_scale(-1,v.d), 2*PI*v3_dot(d, i->n) ) );
            }
        }
        inode_free(i);
        return c;
    }
    else{
        if( i == NULL )
            return C_BLACK;
        else{
            inode_free(i);
            return C_BLACK;
        }
    }
}
Color direct_light( int ns, Vector3 p, Vector3 n, Vector3 v,
Object *ol, PolyLight *l, Material *m )
{
    int k;
    Vector3 r, light_ptdir, inv_light_ptdir;
    Ray s;
    Color c, cl_light;
    Inode *i;
    double g=0;
    c = c_make(0,0,0);
    for( k = 0; k < ns; k++ ){
        s = plight_sample(l,&cl_light);
        r = v3_sub(s.o, p);
        light_ptdir = v3_unit(r);
        inv_light_ptdir = v3_scale( -1, light_ptdir );
        i = ray_intersect(ol, ray_make(p, light_ptdir));
        if( (i == NULL) || (i->t > v3_norm(r)) ){
            g = fabs( v3_dot(inv_light_ptdir,s.d)*v3_dot(light_ptdir, n) );
            c = c_add(c, apply_bphong(m, cl_light, n, light_ptdir, v,
            g*plight_area(l)/SQR(v3_norm(r) ) ) );
        }
        if( i != NULL )
            inode_free(i);
    }
    return v3_scale(1./ns, c);
}
int light_visible(Ray r, Object *ol, PolyLight *l, Color *c)
{
    Inode *i1, *i2;
    i1 = plight_intersect( l, r, c );
    if( i1 != NULL ){
        i2 = ray_intersect( ol, r );
        if( i2 == NULL || (i1->t < i2->t ) ){
            inode_free(i1);
            if( i2 != NULL )
                inode_free(i2);
            return TRUE;
        }
        inode_free(i1);
        if( i2 != NULL )
            inode_free(i2);
    }
    return FALSE;
}
// Extracted from lptrace/aux.c
#include "ptrace.h"
Color mirror_reflect( int first_level, int level, Ray v, Inode *i,
Vector3 p, Object *ol, Material *m )
{
    Vector3 d, c_aux;
    d = v3_sub( v.d, v3_scale( 2*v3_dot( v.d, i->n ), i->n ) );
    c_aux = trace_path( first_level, level, ray_make(p, d), ol );
    return v3_scale( m->ks, c_aux );
}
Color apply_bphong( Material *m, Color lcolor, Vector3 n, Vector3 l,
Vector3 v, Real geom_fac)
{
    Color cs,cd;
    Vector3 h = v3_unit(v3_add(l,v));
    cs = c_scale(m->ks* pow(MAX(0, v3_dot(h,n)),m->se)*geom_fac, lcolor);
    cd = c_mult(m->c, c_scale(m->kd*geom_fac, lcolor) );
    return c_add( cs, cd );
}
Vector3 sort_new_direction( Cone c )
{
    double x, y, z;
    Vector3 v, n = v3_unit(c.d);
    do{
        x = 2*REAL_RANDOM - 1;
        y = 2*REAL_RANDOM - 1;
        z = 2*REAL_RANDOM - 1;
        v = v3_make(x,y,z);
    }
    while( v3_norm(v) > 1 );
    if( v3_dot(v, c.d) < 0 ){
        double s = v3_dot(v3_scale(-1,v), n);
        v = v3_add( v, v3_scale(2*s,n) );
    }
    return v3_unit(v);
}
Bool hit_surface( Ray v, Object *ol )
{
    Inode *i = ray_intersect(ol, v);
    if( i == NULL )
        return FALSE;
    else{
        inode_free(i);
        return TRUE;
    }
}
void adjust_normal( Inode *i, Ray v )
{
    if( i != NULL && v3_dot( i->n, v.d ) > 0 )
        i->n = v3_scale( -1, i->n );
}

7.3 多边形光源 API

以下是多边形光源相关的 API 函数：
| 函数名 | 功能 |
| ---- | ---- |
| void init_plight_list( void ); | 初始化一个空的多边形光源列表。 |
| PolyLight *plight_alloc( Color c, Hpoly *p ); | 返回一个颜色为 c 、形状由 p 定义的多边形光源。 |
| void plight_insert( PolyLight *pl ); | 将多边形光源 pl 插入到多边形光源列表中。 |
| void plight_free( PolyLight *head ); | 清除由 head 指向的多边形光源列表。 |
| Ray plight_sample( PolyLight *p, Color *c ); | 返回一条光线，其原点是多边形光源 p 上的均匀采样点，方向垂直于 p 。 c 接收采样点的颜色。 |
| Real plight_area( PolyLight *p ); | 返回多边形光源 p 的面积。 |
| Inode *plight_intersect( PolyLight *p, Ray r, Color *c ); | 返回光线 r 与多边形光源 p 相交的节点。 c 返回光线的颜色，如果没有相交则返回 NULL 。 |
| Val plight_parse(int pass, Pval *pl); | 负责处理场景描述文件中的多边形光源。 |
| Ray poly3_sample( Hpoly *p ); | 返回一条光线，其原点是多边形光源 p 上的均匀采样点，方向垂直于 p 。 |

7.4 多边形光源代码

以下是多边形光源的代码实现：

// plight/plight.h
#ifndef P_LIGHT_H
#define P_LIGHT_H
#define DIRECT_LIGHT_NSMPLS 3
#include "color.h"
#include "poly.h"
#include "ibl.h"
typedef struct PolyLight{
    struct PolyLight *next;
    Hpoly *p;
    Color c;
} PolyLight;
PolyLight *plight_head;
void init_plight_list( void );
void plight_free( PolyLight *head );
PolyLight *plight_alloc( Color c, Hpoly *p );
void plight_insert( PolyLight *pl );
Ray plight_sample( PolyLight *p, Color *c );
Real plight_area( PolyLight *p );
Inode *plight_intersect( PolyLight *p, Ray r, Color *c );
Val plight_parse(int pass, Pval *pl);
Ray poly3_sample( Hpoly *p );
#endif
// plight/plight.c
#include "plight.h"
void init_plight_list( void )
{
    plight_head = NULL;
}
PolyLight *plight_alloc( Color c, Hpoly *p )
{
    PolyLight *pl;
    pl = NEWSTRUCT(PolyLight);
    pl->next = NULL;
    pl->p = p;
    pl->c = c;
    return pl;
}
void plight_free( PolyLight *head )
{
    PolyLight *pl;
    for( pl = head; pl != NULL; pl=pl->next ){
        free( pl->p );
        free( pl );
    }
}
void plight_insert( PolyLight *pl )
{
    pl->next = plight_head;
    plight_head = pl;
}
Ray plight_sample( PolyLight *pl, Color *c )
{
    int i, r, n = 0;
    PolyLight *aux;
    for( aux = pl; aux != NULL; n++, aux = aux->next );
    r = rand()%n;
    for( aux = pl, i=0; i < r-1; aux = aux->next );
    *c = aux->c;
    return poly3_sample(aux->p);
}
Real plight_area( PolyLight *pl )
{
    Real a = 0;
    while (pl != NULL) {
        a += hpoly3_area(pl->p);
        pl = pl->next;
    }
    return a;
}
Inode *plight_intersect( PolyLight *pl, Ray r, Color *c )
{
    Inode *l = NULL;
    while( pl != NULL && l == NULL ){
        l = hpoly_intersect(pl->p, hpoly3_plane(pl->p), r);
        *c = pl->c;
        pl = pl->next;
    }
    return l;
}
Val plight_parse(int pass, Pval *plist)
{
    Color c;
    struct Hpoly *pl, *pols;
    Val v = {V_NULL, 0};
    if (pass == T_EXEC) {
        Pval *p;
        for (p = plist; p !=NULL; p = p->next) {
            if (p->name == NULL) {
                error("(extense light) syntax error");
            } else if (strcmp(p->name, "color") == 0) {
                c = pvl_to_v3(p->val.u.v);
            } else if (strcmp(p->name, "shape") == 0 && p->val.type == V_HPOLYLIST) {
                pols = p->val.u.v;
            } else error("(extense light) syntax error");
        }
        for(pl = pols; pl != NULL; pl = pl->next)
            plight_insert( plight_alloc( c, pl ));
        v.type = V_PL_LIGHT;
        v.u.v = NULL;
    }
    return v;
}
Ray poly3_sample( Hpoly *p )
{
    Vector3 a, b, c, v0, v1, v2;
    Real r1 = REAL_RANDOM;
    Real r2 = REAL_RANDOM;

综上所述，通过本文介绍的数值近似、蒙特卡罗积分方法、路径追踪算法以及相关的代码实现，我们可以更有效地处理光线传输问题，实现更真实的渲染效果。在实际应用中，可以根据具体需求对这些方法和代码进行调整和优化。

8. 代码模块的详细分析

8.1 路径追踪 API 函数调用流程

路径追踪的核心 API 函数 trace_path 会调用其他多个函数，形成一个复杂的调用流程。以下是该流程的 mermaid 流程图：

graph TD;
    A[trace_path] --> B{光线是否可见到光源?};
    B -- 是 --> C[返回光源颜色];
    B -- 否 --> D{是否有交点且反射深度大于 0?};
    D -- 否 --> E[返回黑色];
    D -- 是 --> F[减少反射深度];
    F --> G{材质 se 参数是否小于 0?};
    G -- 是 --> H[mirror_reflect];
    G -- 否 --> I[sort_new_direction];
    I --> J[direct_light];
    J --> K{新光线是否可见到光源?};
    K -- 是 --> L[不处理];
    K -- 否 --> M[trace_path];
    M --> N[apply_bphong];
    N --> O[累加颜色];
    H --> O;
    O --> P[释放节点];
    P --> Q[返回颜色];

从这个流程图可以看出， trace_path 函数根据不同的条件调用其他函数，实现了路径追踪的核心逻辑。如果光线能直接看到光源，就直接返回光源颜色；如果有交点且反射深度足够，会根据材质的 se 参数决定是进行镜面反射还是继续追踪光线。

8.2 多边形光源 API 函数的使用示例

以下是一个简单的示例，展示如何使用多边形光源的 API 函数：

#include "plight.h"

int main() {
    // 初始化多边形光源列表
    init_plight_list();

    // 创建一个多边形
    Hpoly *poly = ...; // 这里需要根据实际情况创建多边形
    Color light_color = c_make(1.0, 1.0, 1.0); // 白色光源

    // 分配一个多边形光源
    PolyLight *pl = plight_alloc(light_color, poly);

    // 将多边形光源插入列表
    plight_insert(pl);

    // 获取多边形光源的面积
    Real area = plight_area(pl);
    printf("多边形光源的面积: %f\n", area);

    // 从多边形光源采样一条光线
    Color sample_color;
    Ray sample_ray = plight_sample(pl, &sample_color);
    printf("采样光线的颜色: (%f, %f, %f)\n", sample_color.r, sample_color.g, sample_color.b);

    // 模拟一条光线与多边形光源相交
    Ray test_ray = ...; // 这里需要根据实际情况创建测试光线
    Color intersect_color;
    Inode *intersect_inode = plight_intersect(pl, test_ray, &intersect_color);
    if (intersect_inode != NULL) {
        printf("光线与多边形光源相交，颜色: (%f, %f, %f)\n", intersect_color.r, intersect_color.g, intersect_color.b);
        inode_free(intersect_inode);
    } else {
        printf("光线与多边形光源无相交\n");
    }

    // 释放多边形光源列表
    plight_free(plight_head);

    return 0;
}

这个示例展示了如何初始化多边形光源列表、分配光源、插入光源、获取光源面积、采样光线、检测光线相交以及释放光源列表等操作。

9. 优化建议

9.1 路径追踪算法的优化

• 提前终止路径 ：在路径追踪过程中，如果光线的能量已经低于某个阈值，可以提前终止路径追踪，减少不必要的计算。例如，在 trace_path 函数中，可以在每次递归时检查光线的能量，如果能量过低则直接返回黑色。

Color trace_path( int first_level, int level, Ray v, Object *ol )
{
    PolyLight *l = plight_head;
    Color c = C_BLACK, c_aux, w;
    Ray r;
    Inode *i = ray_intersect(ol, v);
    adjust_normal( i, v );
    if( light_visible(v,ol,l,&w) )
        return w;
    if((i != NULL) && level){
        level--;
        Material *m = i->m;
        Vector3 p = ray_point(v, i->t);
        Cone recv = cone_make(p, i->n, PIOVER2);
        if( m->se < 0 )
            c = mirror_reflect( first_level, level, v, i, p, ol, m );
        else{
            Vector3 d = sort_new_direction(recv);
            c = direct_light( DIRECT_LIGHT_NSMPLS, p, i->n,
                             v3_scale(-1,v.d), ol, l, m);
            if( !light_visible(ray_make(recv.o, d), ol, l, &w) ){
                c_aux = trace_path( first_level, level, ray_make(p, d), ol );
                // 检查光线能量
                if (c_aux.r + c_aux.g + c_aux.b < ENERGY_THRESHOLD) {
                    c_aux = C_BLACK;
                }
                c = c_add(c, apply_bphong( m, c_aux, i->n,
                                           d, v3_scale(-1,v.d), 2*PI*v3_dot(d, i->n) ) );
            }
        }
        inode_free(i);
        return c;
    }
    else{
        if( i == NULL )
            return C_BLACK;
        else{
            inode_free(i);
            return C_BLACK;
        }
    }
}

• 重要性采样 ：在半球采样时，采用重要性采样方法，根据光线的贡献度来选择采样方向，而不是均匀采样。这样可以提高采样效率，减少噪声。

9.2 多边形光源的优化

• 合并小多边形 ：如果场景中有很多小的多边形光源，可以将它们合并成一个或几个较大的多边形光源，减少采样和相交检测的次数。
• 空间划分 ：使用空间划分数据结构（如八叉树）来加速光线与多边形光源的相交检测。在 plight_intersect 函数中，可以先检查光线是否与空间划分结构的某个区域相交，再进行具体的多边形相交检测。

10. 总结

本文详细介绍了光线传输与蒙特卡罗方法，包括数值近似、蒙特卡罗积分方法、路径追踪算法、半球均匀采样、直接光照与间接光照分离以及多边形光源的处理等内容。同时，给出了相应的代码模块，并对代码进行了详细分析和优化建议。

10.1 主要知识点总结

知识点	描述
数值近似	通过替换渲染方程中的 (L) 得到近似解，截断纽曼级数可用于求解渲染方程。
蒙特卡罗积分方法	利用大数定律，通过随机采样来近似积分。
路径追踪	从相机发射光线，在场景中不断反射，直到与光源相交，通过多次采样求平均值来提高渲染精度。
半球均匀采样	使用条件概率过程在半球上进行均匀采样。
直接光照与间接光照分离	将总辐射度分为直接辐射度和间接辐射度，分别计算。
多边形光源	分割成三角形进行均匀采样，通过 API 函数管理和操作。

10.2 未来展望

随着计算机图形学的发展，光线传输算法和蒙特卡罗方法还有很大的优化空间。例如，可以结合深度学习技术，利用神经网络来预测光线的传播路径和光照效果，进一步提高渲染效率和质量。同时，对于大规模场景的处理，还需要研究更高效的算法和数据结构，以减少计算量和内存消耗。

通过对这些知识的掌握和应用，我们可以实现更加真实和高效的渲染效果，为游戏开发、电影制作、虚拟现实等领域提供有力的支持。