企业官网建设流程全解析

做工业视觉的朋友前几天甩给我一段代码，说瑕疵检测的误检率卡在 3% 上下，怎么调都下不来。我看了一眼他的流水线：灰度化、高斯模糊、Otsu 二值化、轮廓提取、面积过滤，逻辑没毛病。问题出在二值图上——背景里散落着大片一两个像素的亮点，面积过滤压根拦不住，因为轮廓提取阶段这些小点会互相粘连成大块。我让他把二值图往里收紧两个像素再走轮廓，误检当晚就降到 0.4% 以下。他收的那个操作就是 OpenCV 里的形态学操作，具体动作叫腐蚀（erosion）。

这东西概念简单到一句话能说完：让一个小方块在图上滑一遍，每个位置取覆盖范围内的最小值。但真到项目里，核的形状怎么选、迭代几次、边界怎么处理、为什么腐蚀完目标贴边那一侧没变化，问题一串接一串。这篇就围绕 OpenCV 的腐蚀往下挖，从直觉模型讲到参数等价性，再给一条能直接抄的完整流水线和一份踩坑速查表。刚接触图像处理的同学能看懂原理，已经写过几年代码的人可以从里头挑几个细节带走——尤其是大核加速和迭代等效性这两块，线上跑得快的和跑得慢的，差别基本都在这里。

1. 腐蚀到底在干什么：把结构元素当成一个探针

1.1 用"探针扫图"的直觉模型理解最小值滤波

先把数学定义丢一边，换个脑内画面。想象你手里有一个固定尺寸的印章，比如 3×3 的小方块，中心点标了个红点。你把这个印章的中心点放在图像的第一个像素上，读一下印章覆盖的 9 个像素里最暗的那个值，把这个值记下来，当作输出图在这个位置的像素值。然后印章往右挪一格，重复。整张图扫完，输出图就是腐蚀的结果。

这个"取最暗值"的操作，在灰度图上就是局部最小值滤波。为什么叫腐蚀？因为亮的区域会被"啃掉"一圈。举个数：一片 255 的白色区域旁边是 0 的黑色背景，你用一个 3×3 的核去扫，白色区域最外圈那一层像素，它周围 9 个邻居里至少有一个是 0，取最小值就是 0，于是这一圈白就被吃掉了，白色区域整体缩了一圈。所以腐蚀在视觉上的直接效果就是——亮的变小、暗的变大。

二值图上的解释更直白。你可以把白色前景看成一坨实体，结构元素看成一个探针，规则是：只有当探针完整地落在实体内部时，探针中心那个点才保留为白色，否则变黑。所以那些比核还小的孤立亮点，探针根本放不进去，直接消失。这正是朋友那个项目里去掉背景碎点的原理——碎点的直径小于核的边长，腐蚀一次就全没了。

这里有个很容易翻车的方向问题。腐蚀吃掉的是亮的东西。如果你的原图是白底黑字，文字是暗的、背景是亮的，直接腐蚀只会把背景啃掉、让文字反而显得更粗。这种图必须先做反相，或者二值化时用cv2.THRESH_BINARY_INV，把前景变成白色再处理。我见过不止一次有人在这上面浪费半天，以为是核没调对。

1.2 结构元素：形状决定了你腐蚀"哪个方向"

结构元素（structuring element），也就是我上面说的那个"印章"，官方叫核（kernel）。OpenCV 提供了三种预置形状：MORPH_RECT（矩形）、MORPH_ELLIPSE（椭圆）、MORPH_CROSS（十字）。选哪个不是随便挑的，它直接决定了你从哪个方向收缩。

矩形核最"凶"。3×3 的矩形核一次腐蚀，横竖斜四个方向都收一个像素。它的好处是可分离——一个 k×k 的矩形核，数学上等价于先做一次 k×1 的横向腐蚀、再做一次 1×k 的纵向腐蚀，这个性质后面讲加速的时候会用到。

十字核只收横竖四个方向，斜对角不管。它的特性很有意思：迭代 n 次十字核，等效于一个曼哈顿距离不超过 n 的菱形区域，而不是 (2n+1) 的方阵。很多人以为迭代三次十字核就等于 7×7 矩形，结果发现斜角上的噪点还在，就是因为这个。十字核适合处理那些本身带斜边、又不想把斜角吃得太狠的目标。

椭圆核介于两者之间，理论上各向同性最好，最接近"均匀收缩"。但在小尺寸下，OpenCV 生成的椭圆其实是被多边形近似过的，5×5 的椭圆核和 5×5 的十字核差别很小；到 9×9 以上才开始明显圆润起来。所以如果你只是想去掉两三个像素的毛刺，椭圆核和十字核的实际效果差不多，别在这上面纠结。

我的经验判断很简单：目标形状接近矩形就选矩形核，目标有明确方向性就用十字核，其他情况一律椭圆核。这个默认规则能覆盖八成场景，剩下一成半靠试，最后那点靠肉眼调。

1.3 锚点、边界与默认值：三个最容易忽略的参数

cv2.erode的签名里藏着三个参数，绝大多数人从来没主动设过，但它们在某些场景下会直接改变结果。

锚点（anchor）默认是(-1, -1)，OpenCV 内部会把它解释成核的中心。对奇数尺寸的核，中心就是(k//2, k//2)；对偶数尺寸的核，中心会偏向一侧，比如 4×4 的核锚点落在(2, 2)，导致核在四个方向上不对称。这就是为什么形态学操作几乎只用奇数核——偶数核会让整个结果平移半个像素，肉眼看不出来，但做亚像素级配准或者拼接的时候会要命。除非你有明确的偏置需求，锚点永远用(-1, -1)，手动指定越界还会直接抛异常。

边界处理（borderType）默认是BORDER_CONSTANT，配合cv2.morphologyDefaultBorderValue()这个特殊值。这个默认值有多特殊？对腐蚀来说，它相当于把图像外部全部假定成最大灰度值（8 位图就是 255）。这意味着什么？意味着当一个目标贴着图像边缘时，边缘外侧被假设为纯白，取最小值的时候这些虚拟像素永远不会成为最小值，于是紧贴边界的那一侧不会被腐蚀掉。

这个行为很多人第一次遇到会懵：明明核调得挺大，图片中间的目标缩得很厉害，左上角那个目标却纹丝不动。不是代码写错了，是边界策略导致的。如果你确实希望边缘目标也被正常收缩，可以把borderValue显式设成 0，代价是图像四边会人为产生一圈黑边，后续处理得把这圈裁掉。我的建议是默认值不动，预处理阶段先给图像 pad 一圈背景色，让所有目标都远离边界，这样边界策略就完全不影响结果了。

2. OpenCV 里腐蚀的调用方式与参数拆解

2.1 cv2.erode 签名逐项拆解

Python 侧的完整签名是这样：

cv2.erode(src, kernel, dst=None, anchor=None, iterations=None, borderType=None, borderValue=None)

src是输入图，通道数可以是 1 到 4，但实际操作中我强烈建议只在单通道灰度或二值图上做形态学。多通道图会被逐通道独立处理，边缘处各通道收缩量不一致，容易出现彩色镶边，而且速度还慢。

kernel是结构元素，必须是单通道的uint8矩阵。这里有个非常关键、文档里只写了一句的细节：OpenCV 只使用核里的非零元素参与运算，值为 0 的位置直接跳过。也就是说你完全可以传一个稀疏掩膜进去：

kernel = np.uint8([[0, 1, 0], [1, 1, 1], [0, 1, 0]])

这个核的效果和MORPH_CROSS生成的 3×3 十字核完全一样。反过来说，如果你手搓核的时候不小心把某个该有值的位置写成了 0，那个方向就不会被腐蚀，而且不会报错，纯粹是静默失败。我踩过这个坑——手写了一个 5×5 的核，中间一行漏填了一个 1，结果横向收缩量比纵向少一个像素，查了小半天。

iterations是迭代次数。传None或者不传，OpenCV 按 1 次处理。传 0 或者负数，实测也会被当成 1 次，别指望它做恒等变换。想要原图直出，老老实实传None的核或者干脆跳过这一步。

dst是输出缓冲，一般不用管，返回值会自动分配。但如果这段代码在循环里跑几十万次，提前分配好dst能省掉大量内存分配开销，这个优化在嵌入式或者高帧率场景下挺管用。

C++ 侧对应的调用：

cv::Mat out; cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)); cv::erode(src, out, kernel, cv::Point(-1, -1), 1, cv::BORDER_CONSTANT, cv::morphologyDefaultBorderValue());

cv::morphologyDefaultBorderValue()是 C++ 里那个特殊边界值的正规写法，Python 里一般不用显式传。

还有一条捷径值得知道：cv2.morphologyEx(img, cv2.MORPH_ERODE, kernel)和cv2.erode完全等价。如果你后续还要在同一张图上做开运算、闭运算，统一用morphologyEx反而更整齐，代码可读性更好。

2.2 getStructuringElement 的内部逻辑与自定义核

cv2.getStructuringElement(shape, ksize, anchor=None)这个函数干的事情，就是按你指定的形状和尺寸生成一个uint8矩阵。ksize传(w, h)，返回的矩阵形状是h行w列，注意这个顺序——OpenCV 的 Size 是宽在前，很容易写反。

三种形状生成的核长什么样，直接打出来看最清楚：

import cv2 import numpy as np for shape, name in [(cv2.MORPH_RECT, "RECT"), (cv2.MORPH_CROSS, "CROSS"), (cv2.MORPH_ELLIPSE, "ELLIPSE")]: k = cv2.getStructuringElement(shape, (5, 5)) print(name) print(k) print()

跑一下你会看到，5×5 的椭圆核在这个尺寸下其实是个带圆角的菱形，边缘并不平滑——这不是 bug，是小尺寸下多边形近似的结果。真想拿到平滑的圆，核至少得开到 11×11 以上。

自定义核的用途比预置核广得多。举个我实际用过的场景：扫描件去表格线。表格线是水平的和竖直的细线，文字的主体是块状的，两者在形状上有明确差异。这时候用两个细长的核分两次腐蚀，一次(25, 1)打横线，一次(1, 25)打竖线，就能在不动文字主体的前提下把线条清干净。这种定向打击是预置核做不到的。

再比如细划痕检测，划痕往往是非常细的长条，用一个(1, 9)的竖核腐蚀一次，长度小于 9 的竖向细结构全部消失，剩下的就是真有长度的划痕。这类操作本质上是形态学特征筛选，核的形状就是你的筛选条件。

2.3 迭代次数和大核的等效性：别被"个数"骗了

这是腐蚀里最容易出错、也最有优化价值的一个点。

对矩形核来说，cv2.erode(img, 3x3核, iterations=3)和cv2.erode(img, 7x7核, iterations=1)在数学上是等价的，都是往外扩 3 个像素。一般化：n 次迭代 (2k+1) 的矩形核，等效于一次 (2kn+1) 的矩形核。

对十字核和椭圆核就不成立了。n 次迭代十字核得到的是菱形（L1 距离球），n 次迭代椭圆核会逐渐逼近一个各向同性的内核，但绝不会等于一个大号的矩形。这一点在需要精确控制收缩形状的时候必须记住。

那性能上哪个更好？直觉可能觉得「小核多跑几次」更快，因为单次计算量小。实测结果反过来。

我在一张 1920×1080 的二值图上做过对比（跑 200 次取平均，单位毫秒）：

结论很明确：能一次大核搞定就别迭代。原因在于每次迭代都要完整读写一遍整张图，5 次迭代就是 5 次全图内存往返，而一次 11×11 只读一遍，虽然每个像素的计算量上去了，但内存带宽省下来了，现代 CPU 上后者明显更划算。

更狠的是最后一个方案——矩形核拆成横竖两次一维腐蚀。因为矩形核是可分离的，(11,11)的腐蚀等价于先跑(11,1)再跑(1,11)，计算量从 k² 降到 2k。核越大收益越明显，25×25 的核拆开之后能快七八倍。这个技巧我一般封装成一个函数，凡是核尺寸超过 9 且形状是矩形的地方全走这条路。

3. 完整实操：一条从噪点掩膜到干净目标的腐蚀流水线

3.1 场景设定与素材预处理

光讲参数没意思，走一遍完整流程。假设我们有个检测任务：图里有一批圆形的小目标，需要数出个数并定位。真实图像的麻烦在于——背景不均匀，有零星的高光点，目标边缘还有毛刺，直接二值化之后周围一片碎屑。

预处理顺序我固定用这一套：

灰度化 → 高斯模糊 → Otsu 二值化 → 腐蚀 → 轮廓提取 → 面积过滤。

每一步的理由说清楚。灰度化是必须的，形态学在多通道上做只有坏处。高斯模糊放在二值化之前，用 5×5 的核、标准差 0，目的是压掉高频噪声，让 Otsu 算出来的阈值更稳。有人喜欢把模糊放在二值化之后，那是错的位置——二值化是硬判决，信息已经丢了，再模糊只会把边缘糊成灰，反而制造出新的中间值。

Otsu 自适应阈值比固定阈值靠谱得多，尤其是光照不均的工业图。但如果背景亮度差异极大（比如一半亮一半暗），全局 Otsu 会失败，这时候换成cv2.adaptiveThreshold配合ADAPTIVE_THRESH_GAUSSIAN_C，块大小取 31 到 51 之间，常数项 C 取 5 到 15。

这里必须强调二值化的极性。cv2.THRESH_BINARY是亮变白，cv2.THRESH_BINARY_INV是暗变白。腐蚀吃白色，所以你要让目标变成白色。如果目标是暗背景上的亮斑，用THRESH_BINARY；如果目标是白纸上的黑字，用THRESH_BINARY_INV。这一条写错，后面所有参数调整都是白费。

3.2 分步代码与逐行注释

完整脚本如下，直接能跑：

import cv2 import numpy as np def build_mask(path, blur_ksize=5, invert=False): """读图并生成二值掩膜，前景为白（255）""" img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) if img is None: raise FileNotFoundError(f"读不到图: {path}") # 先模糊再二值化，顺序不能反 if blur_ksize > 1: img = cv2.GaussianBlur(img, (blur_ksize, blur_ksize), 0) flag = cv2.THRESH_BINARY_INV if invert else cv2.THRESH_BINARY _, binary = cv2.threshold(img, 0, 255, flag + cv2.THRESH_OTSU) return binary def erode_mask(binary, ksize=3, shape=cv2.MORPH_ELLIPSE, iters=1): """按指定核做腐蚀，返回新掩膜""" kernel = cv2.getStructuringElement(shape, (ksize, ksize)) return cv2.erode(binary, kernel, iterations=iters) def find_targets(mask, min_area=80, max_area=20000): """提取轮廓并按面积过滤，返回 (轮廓列表, 中心点列表)""" contours, _ = cv2.findContours( mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE ) keep, centers = [], [] for c in contours: area = cv2.contourArea(c) if min_area <= area <= max_area: keep.append(c) (cx, cy), _ = cv2.minEnclosingCircle(c) centers.append((int(cx), int(cy))) return keep, centers if __name__ == "__main__": path = "sample.png" raw = build_mask(path) clean = erode_mask(raw, ksize=5, shape=cv2.MORPH_ELLIPSE, iters=1) contours, centers = find_targets(clean) print(f"腐蚀后目标数: {len(contours)}") # 可视化：原始掩膜标绿，腐蚀后标红 vis = cv2.cvtColor(raw, cv2.COLOR_GRAY2BGR) for (cx, cy) in centers: cv2.circle(vis, (cx, cy), 6, (0, 0, 255), 2) cv2.imwrite("result.png", vis)

几个值得单独说的实现细节。

findContours的第二个参数用RETR_EXTERNAL，只取最外层轮廓。因为我们关心的是目标本身，不需要内部空洞信息，而且外部模式速度快不少。第三个参数CHAIN_APPROX_SIMPLE会压缩掉直线段上的冗余点，对后续算面积没有影响，但内存能省一大截。

minEnclosingCircle返回的第二个值_是半径，这里用不到。如果你要算实际直径，那个半径乘 2 乘像素当量就是物理尺寸，做尺寸测量的项目在这取数。

面积过滤的阈值不是拍脑袋的。min_area=80这个数的由来：假设腐蚀用的是 5×5 核，目标直径至少要比核的边长多出两圈，才不至于被吃干净。也就是说目标的最小直径大概在 7 到 8 像素，圆的面积 π·(3.5)²≈38，考虑到边缘不规整，取 80 比较稳。这个换算过程建议你在自己项目里走一遍，会省掉很多盲目试参数的时间。

3.3 参数调优记录与效果对照

同一张测试图，我把核尺寸和形状扫了一遍，结果如下（目标总数人工标注为 42 个）：

几个观察值得记下来。

矩形 5×5 那一行检出数是 42，正好对上人工标注，但别急着高兴——它的误检是 0，可漏检也是 0 这个结果是运气好。矩形核会把斜角削得比椭圆核狠，本身带斜边的目标用矩形核容易削出缺口，进而影响后续的圆度判断。我最后还是选了椭圆 5×5，检出 44，多出来的 2 个是背景边缘的残留，面积过滤再收紧一点就干净了。

十字核迭代 2 次的那一行是反面教材。它的等效形状是菱形，斜方向只收了 1 个像素，所以斜向偏上偏下的小碎点全漏了。如果你的目标分布有明显方向性，十字核会很好用；如果目标是随机分布的小圆点，别碰十字核。

还有一个没写进表里的结论：腐蚀之后再膨胀回去（也就是开运算），检出数会从 44 掉到 43，但轮廓的圆度明显变好，后续做形状分类的准确率能提升。这个属于后续步骤了，这里先记一笔。

4. 常见报错、异常现象与排查实录

4.1 报错与现象速查表

把我在项目里遇到过、以及被同事问过的问题汇总成表，出问题先按这张表对一遍：

4.2 几个踩过的坑，和它们的真实解法

表里挑几个展开说，因为光看结论不够。

贴边不缩这个问题，我上面提过原理，但实际排查有个更快的办法：拿一张 20×20 的小图，中间画一个 10×10 的白块，跑一次 5×5 的腐蚀，把结果打印成矩阵看。你会清楚看到边界那一侧的数字和中间不一样。用这个小实验验证边界策略，比在大图上瞎猜快得多。

dtype 报错是老生常谈，但变种很多。最常见的是有人用np.mean或者某种除法算出了float64的图，直接丢进cv2.erode。float64其实是支持的，但后续cv2.imwrite存 8 位格式时会截断成怪东西。另一个变种是用布尔数组做掩膜，bool类型 OpenCV 不认，必须astype(np.uint8) * 255。养成习惯：所有进入 OpenCV 函数的图，先确认 dtype 是uint8。

核里有 0这个坑前面提过，再补一个相关细节。getStructuringElement生成的椭圆核对小尺寸来说是带 0 的稀疏矩阵。比如 5×5 椭圆核，四个角上是 0。这意味着它的实际覆盖面积不是 25 个像素，而是 21 个。所以你不能简单地用「核边长减一除以二」来精确推算收缩量，斜角方向的收缩本来就少。需要精确控制的时候，我一般拿一张全白图跑一遍腐蚀，直接量剩下的白色区域尺寸，这个物理测量比算公式可靠。

目标分裂也遇到过。有个项目里，目标是一串连在一起的蜂窝状结构，我用 7×7 的核去噪，结果连接处只有 2 个像素宽，直接被切断了，一坨变成七八个小块。解法不是缩小核，那会漏噪点；正确的做法是先闭运算（先膨胀后腐蚀）把连接处补粗，再做腐蚀。顺序很重要，这个组合后面还会细说。

还有一点，cv2.erode是就地不可逆的。腐蚀之后信息丢了就是丢了，别指望用同样大小的膨胀能完全还原——大核腐蚀再大核膨胀，边缘的圆角会变成直角，细小的凸起也回不来。所以调试阶段一定要保留原始掩膜的副本，binary.copy()这个习惯能救命。

提示：调试形态学参数时，别在完整流程里改。单独写个十行的小脚本，只做二值化和腐蚀，把中间结果用imshow或imwrite存出来看。整条流水线跑一遍十几秒，单独调参零点几秒，效率差几十倍。

5. 腐蚀在真实项目里的组合玩法

5.1 开运算为什么必须"先腐蚀后膨胀"

单独用腐蚀有个绕不开的代价：目标会整体缩小一圈。如果你的后续步骤依赖准确面积或者精确边缘，这个缩小就是误差。开运算（opening）就是冲着这个问题来的——先腐蚀后膨胀，记作open(I) = dilate(erode(I))。

顺序绝对不能反。先腐蚀的作用是剔除：比核小的结构没了。后膨胀的作用是还原：把还活着的主体重新长回接近原始尺寸。因为小结构已经被第一阶段杀死了，膨胀阶段它们不会再长回来，所以开运算的净效果是「保留大结构、去掉小结构、主体尺寸基本不变」。

反过来先膨胀后腐蚀是闭运算（closing），效果是「填小洞、连断裂」。两者不是可交换的，open和close对同一张图的结果往往差得很远，用错方向就是南辕北辙。判断方法很简单：你要去噪点就用开运算，要补窟窿就用闭运算。

OpenCV 里一行搞定：

opened = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel) closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)

内部等价于erode接着dilate，但morphologyEx有一个实测能感知到的优化：当核比较小的时候，它会走一条合并的单遍路径，比你自己串两次函数调用快一点。核越大差别越小。

有个细节值得提：开运算和闭运算本身是幂等的。对同一张图连续做两次开运算，第二次的结果和第一次完全一样（核相同的前提下）。这个性质可以用来判断参数够不够：如果你发现做一次和做两次结果不同，说明还有结构能被这个核影响，可以放心再加。

5.2 内边界、形态学梯度、顶帽里的腐蚀

腐蚀不只是一个滤波器，它还是很多形态学算子的基础构件，理解了它，这些算子就是加减法。

内边界（internal boundary）。用原图减去腐蚀后的图，得到的是目标内侧那一圈边缘。为什么？腐蚀把目标整体缩小了一圈，原图和缩小版在边缘处不重叠，差集正好是这圈边。代码就一行：

inner_edge = cv2.subtract(binary, cv2.erode(binary, kernel))

这个边缘的特点是单像素宽、位于目标内部，比 Canny 出来的双边缘干净得多，做周长测量或者轮廓跟踪的时候很好用。缺点是它依赖形态学，对噪声敏感，所以前面必须先把噪点打掉。

形态学梯度（morphological gradient）。膨胀减腐蚀，得到的是目标的完整外轮廓带，宽度大约是核尺寸。cv2.morphologyEx(img, cv2.MORPH_GRADIENT, kernel)一行调用即可。它的优势是不需要调 Canny 的两个阈值，参数只有一个核尺寸，非常适合批量处理同一类目标的场景。缺点是边缘带宽随核变化，做亚像素定位不合适。

顶帽（top-hat）和黑帽（black-hat）。顶帽是原图减开运算，提取的是「比核小的亮细节」；黑帽是闭运算减原图，提取的是「比核小的暗细节」。这两个算子在做光照不均校正的时候特别好使。背景亮度缓慢变化，属于大尺度结构，开运算会把它保留下来；而你想找的小目标是高频细节，被开运算滤掉了，一减就出来了。我做过一个低对比度字符增强，用 15×15 的核做顶帽，固化的参数直接覆盖了整批样本，比自适应阈值调参省事多了。

这些算子有个共同点：它们的表现完全由底层腐蚀和膨胀的核决定。核选错，上层算子全部失效。所以每次有人问我「形态学梯度效果不好怎么办」，我的回答永远是先回去检查腐蚀那一步的核。

5.3 大核场景下的可分离加速

最后说一个纯工程向的优化，前面提过一句，这里给完整做法。

有些场景必须用大核。比如从一张 4000×3000 的扫描图里去掉整片文字区域，只留签名，文字块的宽度动辄几十个像素，核至少得 25×25 起步。这时候单次大核腐蚀在 CPU 上能跑到几十毫秒，帧率直接崩。

因为矩形核是可分离的，可以拆成横竖两次一维腐蚀：

def erode_rect_separable(img, ksize): """矩形核的可分离腐蚀，等价于 (ksize, ksize) 单次腐蚀""" kx = cv2.getStructuringElement(cv2.MORPH_RECT, (ksize, 1)) ky = cv2.getStructuringElement(cv2.MORPH_RECT, (1, ksize)) tmp = cv2.erode(img, kx) return cv2.erode(tmp, ky)

我在 2048×1536 的二值图上测过一组数（跑 100 次取平均）：

核越大优势越夸张，因为计算量从 O(k²) 降到了 O(2k)。41×41 的时候快了十二倍多，这个差距在实时系统里就是能不能用的分界线。

但这个方法有两个严格前提，缺一不可。

第一，核形状必须是矩形。十字核和椭圆核不可分离，拆开会得到完全不同的结果，不是近似误差的问题，是彻底错误的答案。

第二，边界处理会有微小差异。单次大核在图像边缘处的行为，和先横后竖两次一维腐蚀不完全一致，因为中间结果tmp在横向上已经被腐蚀过，纵向那一步读到的边界像素值已经变了。差异出现在紧贴图像边的 1 到 2 个像素范围内，如果你的目标都离边界有距离（这本来就应该是常态），完全可以忽略。但如果你的 ROI 紧贴图像边缘，建议先 pad 一圈再做，把边界推到视野之外。

还有一个变种用法值得知道：如果你需要的是 n 次迭代小核的效果，也可以先把它换算成等效的大矩形核再做可分离。比如 3×3 迭代 6 次，等效于 13×13 单次矩形核，直接用可分离路径走，速度能快好几倍，而且结果在数学上完全等价（矩形核的迭代等效性是严格的）。

最后分享一个不太起眼但很实用的习惯：凡是形态学操作，我都会在函数里加一句断言，检查输入是不是单通道、dtype 是不是uint8、核尺寸是不是奇数。这三个检查加起来不到五行，但能挡掉我遇到过的绝大多数形态学 bug。写代码的时候多花三十秒，调试的时候少花半小时，这笔账很划算。