1. 视差计算这件事，为什么值得单独拎出来讲

双目立体视觉里，视差图的质量几乎决定了后续所有环节的天花板。你把相机标定做得再准、点云重建的流程搭得再顺，只要视差图在弱纹理区糊成一片、在边缘处拖出长长的尾巴，后面深度换算出来的结果就是一堆没法用的噪点。我接触过的不少项目，前期在硬件和标定上砸了大量时间，最后卡在视差这一步，返工成本高得离谱。

这次要聊的是nnc 算法，全称是 Normalized Cross Correlation，归一化互相关。它在稠密视差计算里属于局部匹配方法的一个经典分支，核心思路不复杂：对左图上的每一个像素，在右图同一行附近开一个窗口滑过去，逐位置算一个归一化相关系数，取相关系数最大的那个位置，左右横坐标之差就是该像素的视差值。听起来像是教科书里的老古董，但实际工程里它的地位一直很稳，原因后面会展开讲。

这篇内容适合谁看？如果你正在做双目测距、三维重建、工业检测里的深度估计，或者单纯想把立体匹配的底层逻辑吃透，那这篇能给你一条从原理到代码落地的完整路径。我会把窗口怎么选、相关系数怎么算、代价聚合怎么优化、后处理怎么收尾这些环节全部拆开，配上可以直接跑的 Python 实现，再把我踩过的坑和调参经验一并倒出来。不需要你有很深的数学背景，但至少要能看懂矩阵运算和基本的图像坐标概念。

先说清楚一个前提：nnc 属于局部算法，它不构建全局能量函数，也不做半全局优化，所以它的强项是速度快、实现简单、对并行友好，弱项是在弱纹理和重复纹理区域容易出错。理解这个边界，你才知道什么时候该用它、什么时候该换方案。下面所有内容都围绕这个定位展开，不夸大也不贬低。

2. nnc 算法的整体设计与思路拆解

2.1 为什么选归一化互相关而不是绝对差

局部立体匹配的核心是定义一个“匹配代价”，代价越小说明两个像素越可能是同一个物点。最直观的代价是 SAD（绝对差之和）或者 SSD（平方差之和），把窗口内对应像素的灰度差累加起来就行。这两个方法实现极简，但有个致命弱点：它们对光照变化极其敏感。左相机和右相机哪怕型号完全一致，由于曝光、角度、镜头镀膜的细微差异，同一物点在两幅图里的灰度值也会有系统性偏移。SAD 直接拿灰度相减，这个偏移会原封不动地进入代价，导致匹配位置偏移。

NCC 的做法是先对窗口内的像素做去均值再归一化，公式是这样的：

NCC(p, d) = Σ[(I_L(p) - μ_L)(I_R(p-d) - μ_R)] / sqrt(Σ(I_L(p) - μ_L)² · Σ(I_R(p-d) - μ_R)²)

分子是协方差，分母是两个窗口标准差的乘积。这个结构带来的好处是：如果右图窗口整体比左图亮了一个常数，去均值之后这个常数被消掉了；如果整体对比度被拉伸了一个系数，归一化之后系数也被消掉了。也就是说，NCC 对线性光照变化具有不变性。这一点在实际场景里非常关键，因为两个相机的响应曲线很难做到完全一致，环境光也不可能绝对均匀。

代价就是计算量。SAD 每个位置只需要一次减法加累加，NCC 要做去均值、算方差、算协方差，浮点运算量大概是前者的三到五倍。但在今天的硬件条件下，这个差距通过积分图或者分离式计算可以大幅压缩，后面实操部分会讲具体怎么优化。我的判断是：除非你的场景光照绝对可控且两相机响应完全一致，否则 NCC 带来的鲁棒性收益远大于它的计算开销。

2.2 局部窗口匹配的基本框架

整个 nnc 视差计算的流程可以拆成五步，我用一个表格把每步的输入输出和关键决策点列清楚：

这个框架是局部算法的通用骨架，nnc 的特殊之处只在第一步的代价定义。理解了这个结构，你换任何局部代价（Census、AD-Census、SAD）都能套进去，只是第一步换个公式而已。我在实际项目里经常把这个框架做成可插拔的，代价函数作为一个参数传进去，方便对比不同方法的效果。

2.3 视差搜索范围的确定逻辑

视差搜索范围[d_min, d_max]直接决定了计算量和可测深度范围。视差和深度的关系是Z = f · B / d，其中 f 是焦距（像素单位），B 是基线长度。假设你的相机焦距 800 像素、基线 60 毫米，你想测的最远距离是 5 米，那对应的最小视差就是800 × 60 / 5000 ≈ 9.6像素，取整就是 10。最近距离 0.5 米对应最大视差800 × 60 / 500 ≈ 96像素。

这个计算必须在写代码之前做，因为搜索范围每多一个像素，代价立方体就多一层，计算量线性增长。我见过有人图省事直接把范围设成 0 到 255，结果一半以上的搜索都是无效的，速度慢了三倍还不止。更稳妥的做法是先根据你的应用场景算出理论范围，再往外扩 10% 到 20% 作为余量，应对标定误差和镜头畸变残差。

注意：视差搜索范围的下界不要设成 0。视差为 0 意味着物点在无穷远，实际场景里几乎不会出现，而且 0 附近容易和背景混淆。从 1 或者理论最小值开始就行。

3. 核心细节解析与实操要点

3.1 窗口大小的取舍：大窗口稳但糊，小窗口锐但噪

窗口大小是 nnc 里最需要反复调的参数，没有之一。窗口越大，参与相关计算的像素越多，统计特性越稳定，在弱纹理区域的抗噪能力越强；但窗口越大，窗口跨越深度不连续区域时，前景和背景的像素被混在一起算相关，边缘处的视差就会被“抹平”，产生所谓的前景膨胀效应。

我做过一组对比实验，在同一组双目图像上分别用 5×5、9×9、15×15、21×21 的窗口跑 nnc，结果很能说明问题：

可以看到，窗口从 5 涨到 15，弱纹理区错误率降了三分之二，但边缘错误率翻了将近三倍。这就是典型的此消彼长。我的经验是：如果你的场景以平面物体为主、深度跳变少，用 15×15 甚至更大；如果场景里有大量物体轮廓需要保留，9×9 是比较平衡的选择；5×5 只在纹理极其丰富且对边缘精度要求极高的场合用。

还有一个折中方案是十字形窗口或者自适应窗口，根据局部纹理强度动态调整窗口形状和大小。这个思路在弱纹理区扩大窗口、在边缘处收缩窗口，效果比固定窗口好不少，但实现复杂度也上去了。新手建议先把固定窗口调明白，再考虑自适应。

3.2 归一化相关系数的数值稳定性处理

NCC 公式里分母是两个标准差的乘积，当窗口内像素几乎完全一致时（比如纯色墙面），标准差趋近于零，分母接近零，相关系数就会爆炸成 NaN 或者无穷大。这是 nnc 实现里最常见的崩溃点，我在第一次写的时候就栽在这上面，整张图跑出来一半是黑的。

处理办法有两个层面。第一层是在分母上加一个极小的常数 epsilon，比如1e-8，防止除零。第二层是设置一个方差阈值，如果窗口内标准差低于这个阈值，直接把这个位置的代价标记为无效，不参与后续的视差选择。这个阈值怎么定？我的做法是统计整幅图窗口标准差的分布，取第 5 百分位数作为阈值，低于它的位置认为是弱纹理区，标记为无效。

def ncc_cost(left, right, win_size, d_min, d_max, var_thresh=1e-4): h, w = left.shape r = win_size // 2 cost = np.full((d_max - d_min + 1, h, w), np.inf, dtype=np.float32) for d in range(d_min, d_max + 1): shifted = np.roll(right, -d, axis=1) for y in range(r, h - r): for x in range(r, w - r): lw = left[y-r:y+r+1, x-r:x+r+1].astype(np.float32) rw = shifted[y-r:y+r+1, x-r:x+r+1].astype(np.float32) lw_m = lw - lw.mean() rw_m = rw - rw.mean() lvar = (lw_m ** 2).sum() rvar = (rw_m ** 2).sum() if lvar < var_thresh or rvar < var_thresh: continue ncc = (lw_m * rw_m).sum() / np.sqrt(lvar * rvar + 1e-8) cost[d - d_min, y, x] = -ncc return cost

注意这里代价取的是-ncc，因为我们要最小化代价，而 NCC 越大越好，取负号就统一成最小化问题了。这个符号转换看着不起眼，但忘了加负号导致视差图完全反过来的情况，我见过不止一次。

3.3 用积分图加速：从分钟级到秒级

上面那段代码是四重循环（视差、行、列、窗口内），在 640×480 的图上跑 90 个视差层，Python 里大概要几分钟，完全没法用。优化的核心思路是把窗口内的求和操作预计算成积分图，让每次窗口求和变成 O(1) 的查表操作。

NCC 需要计算的量包括：左窗口和、右窗口和、左窗口平方和、右窗口平方和、左右窗口乘积和。这五个量都可以用积分图预计算。以左窗口和为例，先构造I_sum积分图，任意矩形区域的和就是四个角点的加减组合。平方和、乘积和同理，各构造一张积分图。这样每个位置的 NCC 计算就变成了常数次查表和四则运算，复杂度从 O(w²) 降到 O(1)。

def integral_image(img): return np.cumsum(np.cumsum(img.astype(np.float64), axis=0), axis=1) def box_sum(ii, y, x, r): y1, y2 = y - r, y + r x1, x2 = x - r, x + r return (ii[y2, x2] - ii[y1-1, x2] - ii[y2, x1-1] + ii[y1-1, x1-1])

实测下来，用积分图优化之后，同样的 640×480 图、90 个视差层，纯 Python 也能压到 2 到 3 秒，如果再用 NumPy 的向量化把视差层循环也去掉，能进到 500 毫秒以内。这个速度对于离线处理完全够用，实时场景再配合降采样和多线程也能接受。

提示：积分图用 float64 构造，避免累加过程中的精度损失。图像尺寸大的时候，float32 的累积误差会让大窗口的求和结果偏差明显。

3.4 亚像素插值：让视差精度突破整数限制

赢家通吃（WTA）选出来的视差是整数，精度就是一个像素。对于测距应用来说，一个像素的视差误差在近距离可能对应几厘米的深度误差，不够用。亚像素插值的思路是利用最优代价位置及其左右邻居的代价，拟合一条抛物线，取抛物线顶点作为亚像素视差。

公式是：

d_sub = d_opt + 0.5 · (C(d_opt-1) - C(d_opt+1)) / (C(d_opt-1) - 2·C(d_opt) + C(d_opt+1))

这里 C 是代价，注意我们用的是-ncc作为代价，所以公式里的符号要对应调整。这个插值的前提是最优位置确实是一个局部极小值，如果邻居代价比它还小（说明最优在边界），插值结果会跑飞，需要加一个判断：只有C(d_opt) < C(d_opt-1)且C(d_opt) < C(d_opt+1)时才做插值，否则保持整数视差。

亚像素插值能把精度提升到 0.1 到 0.2 像素的量级，代价几乎可以忽略。这个环节我强烈建议加上，投入产出比极高。

4. 实操过程与核心环节实现

4.1 完整流程的代码组织

把前面几块拼起来，一个可运行的 nnc 视差计算流程大概长这样。我用的是灰度图输入，如果你手上是彩色图，先转灰度，转换公式用标准的加权0.299R + 0.587G + 0.114B，不要用简单平均，后者会丢失亮度信息。

import numpy as np import cv2 def compute_disparity_ncc(left_gray, right_gray, win_size=9, d_min=0, d_max=64, var_thresh=1e-4): h, w = left_gray.shape r = win_size // 2 n_disp = d_max - d_min + 1 # 预计算左图积分图 L = left_gray.astype(np.float64) ii_L = integral_image(L) ii_L2 = integral_image(L * L) cost_volume = np.full((n_disp, h, w), np.inf, dtype=np.float64) for idx, d in enumerate(range(d_min, d_max + 1)): R = np.roll(right_gray, -d, axis=1).astype(np.float64) ii_R = integral_image(R) ii_R2 = integral_image(R * R) ii_LR = integral_image(L * R) for y in range(r, h - r): for x in range(r, w - r): sL = box_sum(ii_L, y, x, r) sL2 = box_sum(ii_L2, y, x, r) sR = box_sum(ii_R, y, x, r) sR2 = box_sum(ii_R2, y, x, r) sLR = box_sum(ii_LR, y, x, r) n = win_size * win_size varL = sL2 - sL * sL / n varR = sR2 - sR * sR / n if varL < var_thresh or varR < var_thresh: continue cov = sLR - sL * sR / n ncc = cov / np.sqrt(varL * varR + 1e-8) cost_volume[idx, y, x] = -ncc # 赢家通吃 + 亚像素插值 disp = np.zeros((h, w), dtype=np.float32) best = np.argmin(cost_volume, axis=0) for y in range(r, h - r): for x in range(r, w - r): b = best[y, x] if not np.isfinite(cost_volume[b, y, x]): disp[y, x] = np.nan continue if 0 < b < n_disp - 1: c0 = cost_volume[b-1, y, x] c1 = cost_volume[b, y, x] c2 = cost_volume[b+1, y, x] if c1 < c0 and c1 < c2: denom = c0 - 2*c1 + c2 if abs(denom) > 1e-8: offset = 0.5 * (c0 - c2) / denom disp[y, x] = b + d_min + offset continue disp[y, x] = b + d_min return disp

这段代码是教学版本，结构清晰但速度一般。实际部署时我会把内层循环用 NumPy 广播或者 Cython 重写，或者直接上 OpenCV 的StereoBM做对比基线。但理解这个版本每一行在干什么，比直接调库重要得多。

4.2 左右一致性检验：剔除遮挡区的错误匹配

左图上的一个像素在右图里可能根本找不到对应点，因为它被前景挡住了。这种遮挡区的匹配结果是随机的，必须剔除。左右一致性检验的做法是：用左图算一遍视差得到disp_L，再用右图算一遍得到disp_R，然后检查disp_L(x, y)和disp_R(x - disp_L(x, y), y)是否一致，差值超过阈值（通常取 1 到 2 像素）就标记为无效。

def lr_check(disp_L, disp_R, thresh=1.5): h, w = disp_L.shape valid = np.zeros((h, w), dtype=bool) for y in range(h): for x in range(w): d = disp_L[y, x] if not np.isfinite(d): continue xr = int(round(x - d)) if 0 <= xr < w and np.isfinite(disp_R[y, xr]): if abs(d - disp_R[y, xr]) < thresh: valid[y, x] = True return valid

这个检验会剔除掉大约 10% 到 20% 的像素，主要是遮挡区和弱纹理区。剔除之后视差图会有空洞，需要后处理填充。填充策略我一般用两种：小空洞用邻域中值填充，大空洞标记为无效不填，交给下游的点云重建环节处理。盲目填充大空洞会引入虚假的深度信息，比留空更危险。

4.3 中值滤波收尾：去掉孤立的椒盐噪声

一致性检验之后，视差图里还会残留一些孤立的错误点，表现为单个像素的视差和周围差异很大。中值滤波是处理这类噪声的标准手段，窗口取 5×5 或者 7×7，对每个像素取邻域中值。注意中值滤波要在有效像素上做，无效像素不参与中值计算，否则会把 NaN 传播开。

def median_filter_valid(disp, valid, ksize=5): r = ksize // 2 out = disp.copy() h, w = disp.shape for y in range(r, h - r): for x in range(r, w - r): if not valid[y, x]: continue patch = disp[y-r:y+r+1, x-r:x+r+1] mask = valid[y-r:y+r+1, x-r:x+r+1] vals = patch[mask] if len(vals) > 0: out[y, x] = np.median(vals) return out

中值滤波的窗口不要开太大，7×7 以上会把真实的细小结构也抹掉。我一般用 5×5，配合前面的亚像素插值，边缘保留和噪声抑制的平衡比较好。

5. 常见问题与排查技巧实录

5.1 视差图整体偏移或反向

这是新手最容易遇到的问题，症状是视差图看起来有结构但整体数值不对，或者左右完全颠倒。排查顺序是这样的：先检查np.roll的方向，右图应该往左移还是往右移取决于你的视差定义。标准定义是disp = x_L - x_R，右图对应点应该在左图对应点的左边，所以np.roll(right, -d)是对的。如果搞反了，视差全是负的或者整体偏移一个常数。

再检查代价的符号。前面说过 NCC 越大越好，代价要取负。如果忘了取负，argmin选出来的是相关性最差的位置，视差图会完全乱掉。这两个点我每次写新代码都要确认一遍，因为一旦搞错，后面的调试全是白费功夫。

5.2 弱纹理区大面积无效

如果视差图里大片区域是 NaN，说明方差阈值卡得太严。先统计一下窗口方差的分布，看看第 5 百分位数是多少，把var_thresh调到那个量级。但要注意，阈值调太低会让弱纹理区的匹配结果变得随机，虽然图上有值了，但都是错的。正确的做法是接受弱纹理区无效这个事实，在下游用多帧融合或者结构光辅助来补，而不是硬调参数把错误结果“调出来”。

5.3 边缘处视差拖尾

前景物体边缘出现一条视差逐渐过渡的拖尾，这是窗口跨越深度不连续面的典型症状。缓解办法有三个：缩小窗口、用自适应窗口、在代价聚合阶段加边缘感知权重。最实用的是缩小窗口配合后处理，把边缘区域的视差用形态学操作收一收。如果对边缘精度要求极高，那就得上半全局或者基于深度学习的方法了，局部算法在这个问题上有天然上限。

5.4 常见问题速查表

5.5 几个踩坑心得

第一个心得：先把单张图跑通再上视频流。视频流里帧间差异、运动模糊、曝光变化会引入一堆额外变量，单张图都调不好的话，视频流只会更乱。我习惯拿一张标准双目数据集（比如 Middlebury 的某组图）做基线，代码改完先在这张图上验证，数值对了再换自己的数据。

第二个心得：视差范围宁小勿大。前面算过理论范围，实际用的时候在这个范围上再加 10% 就够了。范围每多一层，计算量和内存占用都线性增长，而且大范围搜索容易在重复纹理区匹配到错误的远处位置。

第三个心得：保存中间结果。代价立方体、初始视差、一致性掩码、滤波后视差，每一步都存下来。出问题的时候能快速定位是哪一步坏的，比重新跑一遍猜要高效得多。代价立方体文件大，可以只存几个关键视差层做抽查。

6. 性能优化与工程落地的一些补充

6.1 多尺度策略：先粗后精

全分辨率上直接跑大范围搜索很费时，一个实用的加速手段是金字塔多尺度。先在降采样 4 倍的图上跑一遍 nnc，得到粗略视差，然后把视差范围缩小到粗视差附近的正负几个像素，再在原分辨率上精搜。这样总计算量能降一个数量级，精度损失很小。

具体做法：原图降采样到 1/4，视差范围也除以 4，跑 nnc 得到disp_coarse。上采样回原尺寸，每个像素的搜索范围设为[4·disp_coarse - 4, 4·disp_coarse + 4]，在这个窄范围内做全分辨率 nnc。注意上采样要用最近邻或者双线性，别用会引入新像素值的插值方式，否则粗视差的误差会被放大。

6.2 并行化：视差层之间天然独立

nnc 的代价计算里，每个视差层的计算是完全独立的，天然适合并行。Python 里可以用multiprocessing把视差层分到多个进程，或者用 NumPy 的向量化把视差层循环消掉。我用过的一个写法是把整个代价立方体用广播一次性算出来，内存换时间，640×480×90 的 float32 立方体大概 110 MB，现代机器完全扛得住。

# 向量化版本的核心思路（示意） # 把 right 图按视差层堆叠成 (n_disp, h, w) right_stack = np.stack([np.roll(right_gray, -d, axis=1) for d in range(d_min, d_max+1)]) # 后续的积分图、窗口求和全部在 stack 上批量做

向量化之后 Python 层的循环只剩窗口求和那部分，如果再把窗口求和也用scipy.ndimage.uniform_filter之类的卷积操作替代，整个流程能压到百毫秒级。

6.3 内存与精度的平衡

代价立方体是内存大户，视差层数乘以图像尺寸再乘以数据类型字节数。90 层、640×480、float32 就是 110 MB，如果图像是 1280×960 就变成 440 MB，多路视频同时处理很容易爆内存。两个办法：一是用 float16 存代价，精度损失在可接受范围内；二是分块处理，把图像切成条带，逐条带算完就释放。我一般用分块，块高度取 64 或 128，配合重叠区域避免边界效应。

注意：分块处理时块与块之间要有窗口半径大小的重叠，否则块边界处的窗口会缺像素，算出来的视差在边界处是错的。重叠区域算完之后丢弃，只保留块中心的有效部分。

7. 写在最后的一点个人体会

nnc 这个算法我从学生时代用到现在，中间换过 Census、AD-Census、SGM，也试过基于学习的方案，但每次遇到新场景需要快速搭一个基线的时候，第一个想到的还是它。原因很简单：它的行为可预测。参数调错了，你知道是窗口的问题还是阈值的问题；结果不对，你知道去查符号还是查方向。这种可解释性在工程调试里太宝贵了。

它当然不是万能的。弱纹理、重复纹理、大遮挡这些场景，局部算法有天花板，硬调参数只会把错误藏起来而不是消掉。我的做法是把它当成一个可靠的基线，先用它把整个流程跑通、把标定和坐标转换验证对，然后再根据具体场景的短板去换更高级的匹配算法。流程框架是通用的，换的只是代价计算那一块，前面搭的积分图、一致性检验、后处理全都能复用。

如果你正在入门立体视觉，我建议你亲手把上面那段教学版代码敲一遍，别直接调库。调库五分钟出结果，但你对视差图里每个像素是怎么来的没有感觉，出了问题也不知道从哪查。自己写一遍，哪怕慢一点、结果糙一点，那个理解是调库换不来的。等你能看着视差图说出“这块是弱纹理所以无效、那条边是窗口太大所以拖尾”，你就真正掌握这个算法了。