3D高斯泼溅技术的原理与代码实现

可视化演示

糖豆表示

先看那盒糖豆。你挑出一颗蓝色软糖，它占据的空间可不是一个点，而是一小团“模糊的区域”——中心最实，边缘渐淡。数学上这种“软乎乎的糖”就叫高斯分布。3D高斯泼溅就是把整个场景当成一个巨大的糖豆拼贴：每一颗糖豆是一个三维高斯椭球，它有胖瘦长短（协方差矩阵）、有中心位置（均值）、有颜色和不透明度。你站远看，无数糖豆叠在一起就糊成了芒果；凑近看，每颗糖豆的边缘都是渐隐的，所以拼缝不明显。

\[

G(\boldsymbol{x}) = \frac{1}{(2\pi)^{3/2}|\boldsymbol{\Sigma}|^{1/2}} \exp\left(-\frac{1}{2}(\boldsymbol{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1} (\boldsymbol{x}-\boldsymbol{\mu})\right)

\]

1. 均值向量：\(\boldsymbol{x}-\boldsymbol{\mu}\)——“你站的位置离糖豆中心有多远”，离得越远味道越淡。

$$\boldsymbol{\mu} = (\mu_x, \mu_y, \mu_z)$$

2. 协方差矩阵：\(\boldsymbol{\Sigma}\)——它是糖豆的“身材档案”，对角线记录三个方向的胖瘦，非对角项记录它歪着身子还是站着。

$$\boldsymbol{\Sigma} = \boldsymbol{R}\boldsymbol{S}\boldsymbol{S}^\top\boldsymbol{R}^\top$$

3. 指数衰减：\(\exp(-\frac{1}{2}\ldots)\)——“越远越淡”的自然衰减曲线，保证糖豆没有生硬的边界，叠起来才自然。

$$e^{-\frac{1}{2}d^2}$$

所以优化糖豆时，真正要调的“旋钮”就这几样：位置\(\boldsymbol{\mu}\)、旋转矩阵\(\boldsymbol{R}\)、缩放对角\(\boldsymbol{S}\)、不透明度\(\alpha\)以及颜色。它们全是从训练照片里自动学出来的——糖豆们自己会摆姿势，不用你一颗颗手捏。

投影光栅

糖豆在三维空间摆好了，可相机拍到的是一张平面照片。每颗胖糖豆投向底片，会变成一个扁扁的椭圆影子。怎么算这个影子？高斯形状有一个妙处：高斯在相机针孔模型下的透视投影，近似还是高斯，只不过中心挪了、胖瘦变了。这个“从3D糖豆到2D椭圆影”的变换，就靠观察矩阵\(W\)和雅可比矩阵\(J\)配合完成。

\[

\boldsymbol{\Sigma}' = \boldsymbol{J}\boldsymbol{W}\boldsymbol{\Sigma}\boldsymbol{W}^\top\boldsymbol{J}^\top

\]

1. 观察变换：乘以\(\boldsymbol{W}\)——把糖豆从世界坐标系搬到相机坐标系，相当于“走到相机跟前，转头看糖豆”。

$$\boldsymbol{W}\boldsymbol{\Sigma}\boldsymbol{W}^\top$$

2. 透视线性化：\(\boldsymbol{J}\)是雅可比矩阵——针孔投影本来会扭曲形状，但靠近投影中心的小范围里，扭曲近似成线性缩放，\(J\)记录了这个缩放的斜率。

$$\boldsymbol{J} = \frac{\partial \boldsymbol{u}}{\partial \boldsymbol{x}}$$

3. 两段拼接：\(\boldsymbol{\Sigma}'\)——先观察变换、再透视缩放，最终得到屏幕上的2D椭圆糖影，画像素时直接用。

$$\boldsymbol{\Sigma}' = \boldsymbol{J}(\boldsymbol{W}\boldsymbol{\Sigma}\boldsymbol{W}^\top)\boldsymbol{J}^\top$$

传统光栅化要一个三角形一个三角形地画，而3DGS是“按糖豆画椭圆”。因为高斯天然是软的，椭圆边缘自动渐隐，拼出来的画面没有锯齿马赛克感。这就是它敢叫“泼溅”（splatting）的原因——像把颜料甩到画布上，甩出来的不是墨点，是柔和的色斑。

叠影成画

几百个椭圆影子同时落在同一块底片上，怎么办？按“谁离相机近谁先画”的顺序叠起来。这就是画家们说的“近大远小遮挡”：近处的糖豆不透明，就把后面的糖豆遮住了；半透明的糖豆呢，就让它透一点后面的颜色。这个叠加过程有专门的公式——alpha合成。

\[

C = \sum_{i=1}^{n} c_i \alpha_i \prod_{j=1}^{i-1}(1-\alpha_j)

\]

1. 深度排序：下标\(i\)从近到远排——像排队插花，先来的先插入画面。

$$i = 1, 2, \ldots, n$$

2. 权重计算：\(\alpha_i\)是第\(i\)颗糖豆的不透明度，\(\prod_{j=1}^{i-1}(1-\alpha_j)\)是它前面所有糖豆透光率的乘积——前面遮得越多，后面露出来的机会越小。

$$w_i = \alpha_i \prod_{j=1}^{i-1}(1-\alpha_j)$$

3. 累加求和：\(\sum c_i w_i\)——每颗糖豆贡献的颜色加权求和，得到最终像素色。

$$C = \sum_{i=1}^{n} w_i c_i$$

这个公式就是让糖豆拼贴画能“以假乱真”的关键工艺。它全程可微——意思是如果发现某个像素颜色不对，能反向算出是哪颗糖豆的哪个参数该背锅。传统光栅化做不到这么漂亮的可微性，这正是3DGS能一边画一边学的高明之处。

照图调糖

糖豆摆好了，画面渲染出来了，但和真实照片一比，还是差那么点意思：颜色偏了、边缘糊了、某一撮糖豆太密了。于是进入整个流程最核心的环节：拿着照片当标尺，给糖豆打分。分数越低说明拼得越像。3DGS的训练损失由两部分构成：L1损失管整体颜色接近度，D-SSIM损失管局部结构相似度，两者按比例混合。

\[

\mathcal{L} = (1-\lambda)\mathcal{L}_1 + \lambda \mathcal{L}_{\text{D-SSIM}}

\]

1. 像素差：\(\mathcal{L}_1 = \frac{1}{N}\sum |I_{render} - I_{photo}|\)——渲染图与照片每个像素的绝对差值平均，数值越小颜色越接近。

$$\mathcal{L}_1 = \frac{1}{N}\sum_{p}|\hat{I}_p - I_p|$$

2. 结构损失：\(\mathcal{L}_{\text{D-SSIM}} = 1 - \text{SSIM}(\hat{I}, I)\)——SSIM衡量两张图的亮度、对比度、结构三个维度的相似度，值越接近1越好，所以用它补足L1看不到的“纹理质感”。

$$\mathcal{L}_{\text{D-SSIM}} = 1 - \text{SSIM}(\hat{I}, I)$$

3. 混合系数：\(\lambda\)（通常取0.2）——给“卖相”分配两成注意力，给“口味”分八成，两者合起来才是最终优化目标。

$$\mathcal{L} = 0.8\mathcal{L}_1 + 0.2\mathcal{L}_{\text{D-SSIM}}$$

有了损失函数，接下来就是梯度下降的活：把损失对每个糖豆的位置、旋转、缩放、颜色、透明度求导，让它们各自往“让损失变小”的方向挪一小步。每迭代一轮，糖豆们就更贴近真实照片一点。一轮、两轮……几千轮之后，拼贴画和照片几乎看不出差别。这整个过程叫“自适应优化”——糖豆自己会调整，你只负责摆好相机、拍好照片。

密度调控

训练中最妙的部分来了：糖豆的数量不是一开始就定死的。你可能会想，干脆一开始就撒几百万颗糖豆？不行，那样训练慢、显存爆，而且很多地方根本不需要那么多糖。3DGS的做法是让糖豆自己“繁殖”和“淘汰”——这就叫自适应密度控制。

\[

\text{if } \nabla_{\boldsymbol{\mu}}\mathcal{L} \text{ 大 and } \boldsymbol{\Sigma} \text{ 大} \Rightarrow \text{拆分}; \quad \text{if } \nabla_{\boldsymbol{\mu}}\mathcal{L} \text{ 大 and } \boldsymbol{\Sigma} \text{ 小} \Rightarrow \text{克隆}

\]

1. 梯度信号：\(\nabla_{\boldsymbol{\mu}}\mathcal{L}\)——这只手推得用力，说明这颗糖豆的位置严重不对，需要“纠正兵力部署”。

$$\nabla_{\boldsymbol{\mu}}\mathcal{L} = \frac{\partial \mathcal{L}}{\partial \boldsymbol{\mu}}$$

2. 拆分：糖豆太大且位置不对时，把它沿最长轴一分为二，两颗小糖豆的子代数由原协方差决定——大块头拆成小块头，覆盖更精细。

$$\boldsymbol{\Sigma}_1, \boldsymbol{\Sigma}_2 \leftarrow \text{split}(\boldsymbol{\Sigma})$$

3. 克隆：糖豆太小但位置不对时，复制一颗挪到附近的偏移位置，让局部“兵力”更密集。

$$\boldsymbol{\mu}_2 = \boldsymbol{\mu}_1 + \epsilon$$

同时，每隔一定步数会检查所有糖豆的不透明度：如果哪颗糖豆透明得像空气（\(\alpha\)趋近0），说明它对画面毫无贡献还白占显存，直接删除。这套“繁殖-淘汰”机制让糖豆数量在训练过程中自动膨胀到几十万到几百万颗，哪里细节多就哪里密集，哪里一片空就哪里稀疏——最终得到的是一个精准分配算力的糖豆军团。

性能进化

为什么3DGS能比NeRF快几十倍？打个比方：NeRF像一名画家，画每个像素前都要跑进房间深处翻找“这个点应该是什么颜色”的配方表（多层感知机MLP），沿途还要反复采样几十上百次光线位置，每次都得重新算一遍；3DGS干脆把糖豆直接摆好，画每个像素时只需问一句“哪些豆子投到了这里？”然后快速按深度叠一下就行。

\[

\text{NeRF: } C(\boldsymbol{r}) = \int_{t_n}^{t_f} T(t)\sigma(\boldsymbol{r}(t))c(\boldsymbol{r}(t),\boldsymbol{d})dt \quad \text{vs} \quad \text{3DGS: } C = \sum_i c_i \alpha_i \prod_{j<i}(1-\alpha_j)

\]

1. NeRF的积分：\(\int\)——光线路径上每个点都要查一遍密度\(\sigma\)和颜色\(c\)，然后积分加总，像沿路跑遍每个驿站收信。

$$C(\boldsymbol{r}) = \int_{t_n}^{t_f} T(t)\sigma(t)c(t)dt$$

2. 3DGS的求和：\(\sum\)——只有糖影覆盖到这个像素的糖豆参与计算，每个像素覆盖的糖豆数量通常只有几十颗，算起来自然是闪电速度。

$$C = \sum_{i \in \text{pixel}} c_i \alpha_i T_i$$

3. 显式vs隐式：NeRF把场景“记”在神经网络权重里，要经过网络前向推理才能读取；3DGS的糖豆参数是裸数据，GPU直接读取光栅化，天然为实时渲染而生。

$$\text{重量级} \approx \text{推理开销大}, \quad \text{轻量级} \approx \text{直接查表}$$

得益于这种“显式糖豆+光栅化”的组合，3DGS在训练完后的渲染速度能达到100fps以上，足以在消费级显卡上自由漫游。这也让它成为数字孪生、VR/AR、影视特效等需要实时交互场景的首选技术——不再像NeRF那样只适合离线出图。

工程落地

糖豆世界的理论很美好，真正动手训练一锅3DGS需要什么？先得拍好照片。绕着一个物体或走进一个房间，拍几十到几百张照片，保证每两个相邻视角之间重叠度足够。然后用COLMAP做“相机标定”——相当于给你的糖豆士兵们划定精确的编制：每张照片是在哪个位置、朝哪个方向拍的。姿势错误会直接导致训练崩塌，就像糖豆被要求摆出“不可能的姿势”。

\[

\text{COLMAP: } \{R_i, t_i, K\}_{i=1}^N = \arg\min \sum_{i,j} \| \pi(K, R_i, t_i, X_j) - u_{ij} \|^2

\]

1. 相机位姿：\(R_i, t_i\)——第\(i\)张照片的旋转和位移，就是相机在空间里站在哪、往哪看。

$$P_i = [R_i \mid t_i]$$

2. 内参矩阵：\(K\)——镜头自身的焦距和畸变，告诉你这张照片是广角还是长焦拍的。

$$K = \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix}$$

3. 投影与误差：\(\pi(K, R_i, t_i, X_j)\)——把3D点投影到2D图像坐标，与实际检测特征点\(u_{ij}\)差得越小，标定越准。

$$\pi(\cdot) = \left(\frac{x'}{z'}, \frac{y'}{z'}\right)$$

拿到标定数据之后，初始化一片稀疏的高斯点云，然后进入“照图调糖”训练流程。最佳实践是：先用官方代码库在单个GPU上训练数十分钟到数小时（视场景规模而定），期间密切观察损失曲线和可视化中间渲染结果；导出时采用splat格式或转换为PLY点云格式供不同端侧使用。显存不够时减少初始点数、降低图像分辨率，或用分块训练策略。等你熟练了，会发现这套流程像做菜——COLMAP是备菜，训练是炒菜，导出装盘，火候和配料比例都在实践中慢慢掌握。

AI 应用场景

Python 演示

import numpy as np class GaussianField:    def __init__(self, count=128):        self._pos = np.random.rand(count, 2).astype(np.float32) * 1.0        self._scale = np.random.rand(count, 2).astype(np.float32) * 0.08 + 0.01        self._color = np.random.rand(count, 3).astype(np.float32) * 0.5 + 0.25        self._alpha = np.full(count, 0.3, dtype=np.float32)     def render(self, height=32, width=32):        ys, xs = np.mgrid[0:height, 0:width].astype(np.float32) / max(height, width)        out = np.zeros((height, width, 3), dtype=np.float32)        for i in range(len(self._pos)):            dx = xs - self._pos[i, 0]            dy = ys - self._pos[i, 1]            weight = np.exp(-0.5 * ((dx / max(self._scale[i, 0], 1e-3)) ** 2 +                                    (dy / max(self._scale[i, 1], 1e-3)) ** 2))            alpha = self._alpha[i] * weight            out = out * (1 - alpha[..., None]) + self._color[i] * alpha[..., None]        return np.clip(out, 0, 1)     def train(self, target, epochs=300, lr=0.05):        for epoch in range(epochs):            rendered = self.render(*target.shape[:2])            loss = float(np.mean((rendered - target) ** 2))            grad_img = 2 * (rendered - target) / target.size            for i in range(len(self._pos)):                dx = xs - self._pos[i, 0]                dy = ys - self._pos[i, 1]                weight = np.exp(-0.5 * ((dx / max(self._scale[i, 0], 1e-3)) ** 2 +                                        (dy / max(self._scale[i, 1], 1e-3)) ** 2))                alpha = self._alpha[i] * weight                g = grad_img * (self._color[i] - out_prev) * alpha[..., None]                self._pos[i, 0] -= lr * float(np.sum(g[..., 0] * dx * weight))                self._pos[i, 1] -= lr * float(np.sum(g[..., 1] * dy * weight))                self._color[i] -= lr * float(np.sum(grad_img * alpha[..., None]))                self._alpha[i] -= lr * float(np.sum(grad_img * weight[..., None]))            if epoch % 30 == 0:                print("epoch", epoch, "loss", round(loss, 6)) if __name__ == "__main__":    target = np.zeros((32, 32, 3), dtype=np.float32)    ys, xs = np.mgrid[0:32, 0:32].astype(np.float32)    mask = ((xs - 16) ** 2 + (ys - 16) ** 2) < 64    target[mask] = [1.0, 0.6, 0.2]    ys, xs = np.mgrid[0:32, 0:32].astype(np.float32)    field = GaussianField(count=64)    field.train(target, epochs=300, lr=0.05)    final = field.render(32, 32)    print("final mse", round(float(np.mean((final - target) ** 2)), 6))

1. self._pos = np.random.rand(count, 2)初始化每颗糖豆的位置，随机撒在画布上。
2. weight = np.exp(-0.5 * ((dx / scale_x)**2 + (dy / scale_y)**2))计算每个像素离糖豆中心的“糖浓度”，越近越浓。
3. out = out * (1 - alpha[..., None]) + self._color[i] * alpha[..., None]这就是alpha合成公式，把新糖影叠到已有画面上。
4. grad_img = 2 * (rendered - target) / target.size求渲染图和目标图的误差梯度，指导糖豆往哪儿挪。
5. self._pos[i, 0] -= lr * ...按梯度方向微调这颗糖豆的位置、颜色和透明度。

常见误区

面试题