区域生长与分裂合并：经典图像分割的工程实践与参数调优

1. 这两个"老古董"算法凭什么还留在工具箱里

图像分割这个词写进简历容易，真落到具体项目里就难。前阵子帮一个做表面缺陷检测的团队梳理他们的分割流程，一张 2048×1536 的工业相机图，缺陷区域往往只有几百个像素，训练样本攒了大半年还不到两百张。他们先后试过几个主流的分割网络，效果时好时坏，换一批来料就崩。最后反而是我用二十分钟写的一个区域生长加几行后处理，把漏检率压了下来。这件事让我又一次确认：区域生长和分裂合并这两套上世纪就被系统化的经典图像分割方法，今天依然有它们不可替代的位置，关键看你会不会用、用在什么地方。

这篇文章面向的是真正要落地的人：可能是做工业视觉的工程师，可能是医学影像或显微图像分析方向的研究生，也可能是刚接触图像处理、被"阈值怎么定"卡住的新手。我会把两种算法的内在逻辑、参数怎么算、代码怎么写、坑在哪里，一条条摊开讲。我不打算写成教科书，而是按一个实际做过项目的人的思路来：先讲为什么这么选，再讲具体怎么干，最后讲那些文档里不会写、只有踩过才知道的细节。

1.1 深度模型没吃掉的那块地盘

先说清楚这两种算法今天还能干什么。它们有几个深度学习方案短期比不了的特点：不需要训练数据，参数少且可解释，单张图推理时间可以压到毫秒级，在没有 GPU 的嵌入式设备上也能跑。在下面这几类场景里，它们往往比一个大模型更合适。

• 样本极度稀缺：缺陷种类多、单类样本个位数，训练集根本撑不起一个网络。
• 结果需要解释：客户要问"为什么这块被判为缺陷"，你能指着种子点和灰度差阈值说清楚，而不是掏出一张热力图。
• 算力受限：产线上的工控机没有独立显卡，或者要在功耗受限的设备上跑。
• 作为预处理环节：先用经典方法把候选区域圈出来，再交给后面的分类器或测量模块，能大幅减少计算量。
• 交互式标注工具：人工点几个种子点就能立刻得到分割结果，比让标注员一笔一笔刷快得多。

反过来说，它们的短板也很明确：对噪声和光照变化敏感，参数需要针对具体图像调，遇到纹理复杂、边界模糊的目标容易翻车。所以真正做项目的时候，我一般把这两种算法当成"快速基线"来用——先跑通，看数据到底长什么样，再决定要不要上更重的方法。

1.2 两条相反的路线：自下而上与自上而下

区域生长和分裂合并最有趣的地方在于，它们解决的是同一个问题，走的却是完全相反的路。

区域生长是自下而上的。它从一个或几个种子像素出发，按照某种相似性准则，把周围"长得像"的像素一个个吞进来，区域像水面上的油渍一样慢慢扩大，直到碰到明显不同的边界才停下。整个过程是"从点到面"。

分裂合并是自上而下的。它先把整幅图当成一个大区域，判断这个区域够不够"均匀"——不够就劈成四块，四块各自再判断，不行再劈，直到每一块都足够均匀或者小到不能再小。劈完之后反过头来，把相邻且相似的碎块重新拼起来。整个过程是"先砸碎，再粘合"。

这两条路带来的工程差异非常实际，我整理成一张表：

我个人的使用习惯是：如果目标内部灰度或颜色比较均匀、边界清楚，优先区域生长，快且准；如果图像里有大小不一的一堆目标、而且我不知道从哪儿下种子，那分裂合并更省心。两者还可以串起来用，后面会讲具体怎么搭。

2. 区域生长：从一颗种子长成一片区域

区域生长的原理一句话就能说完：给定种子，反复把邻域内满足相似性条件的像素并入当前区域，直到没有新像素可以并入。但真写起来，有三个决策绕不开，而且每一个都会实质性地改变输出结果。

2.1 三个绕不开的决策：种子、准则、停止

第一个决策是种子怎么来。手动模式适合交互工具，人在图上点一下，程序从那里开始长。批处理模式必须自动选种子，常见做法有四种：直方图上找峰值对应的像素、按固定网格采样后挑局部方差最小的点、用梯度幅值最小的点（说明处在平坦区域内部）、或者干脆对每个未标记像素都尝试长一次，最后按面积筛选。最后这种最费时但最不容易漏掉目标。

第二个决策是相似性准则。这是算法的心脏，决定"什么算像"。后面单独展开讲。

第三个决策是停止条件。表面上看，停止是准则的自然结果——没有像素满足条件就停了。但实际项目中，光靠准则往往停不下来，因为总有一些"灰度介于两者之间"的过渡像素能让区域一路爬过去。所以我通常额外加两道闸：一是最大面积上限，超过就强制截断；二是边界门控，邻域位置的梯度幅值超过某个值就不允许生长。这两道闸在工业图上非常管用，能挡住绝大部分泄漏。

另外还有一个容易被忽略的细节：连通性选 4 邻域还是 8 邻域。8 邻域生长更快、能穿过对角线的窄缝，但也更容易从对角缝隙"漏"出去。做精细分割时我一般先用 8 邻域，发现泄漏再改 4 邻域。

2.2 相似性准则怎么定，阈值怎么算

这是新手最容易拍脑袋的地方。准则的写法大致有三类，各有各的毛病：

第一类，跟种子比。判据是|f(p) - f(seed)| <= T。实现最简单，但有个致命问题：如果种子恰好落在目标的亮部，暗部就长不进来；反过来种子落暗部，亮部长不进来。只在目标内部灰度非常均匀、光照平坦时才推荐。

第二类，跟当前区域均值比。判据是|f(p) - mean(R)| <= T。能适应目标内部缓慢变化的灰度，比第一类好用得多。但它有个隐蔽的副作用：区域越大，均值越"钝"，判据越来越宽松，容易出现"越吃越想吃"的漂移。解决方法是把均值换成中位数，或者限制区域面积。

第三类，跟已接受的邻居比。判据是|f(p) - f(q)| <= T，其中 q 是 p 的已入队邻居。这就是漫水填充的写法，它能沿着灰度渐变一路爬上去，非常顽强，但也最容易一路漏出边界。适合分割渐变明显的区域（比如天空、水面），不适合对比度低的场景。

阈值 T 怎么定？我给一个可以直接用的算法。假设图像是 8 位灰度，你先在一小块纯背景区域上算像素灰度标准差 σ，那就是传感器噪声的量级，工业相机一般在 2~5 个灰度级。阈值取下限T >= 2.5σ，保证噪声不会被误判成真实差异。同时，如果目标和背景的灰度差是 Δ，还要满足T <= Δ/2，否则会跨过边界。

举个例子：某零件表面，背景灰度均值 60、噪声 σ 约 3，缺陷区域灰度均值 120。按公式，T >= 7.5且T <= 30，取 T = 8 到 10 都很安全。实际跑下来 T=8 时边界最贴合，T=15 就开始往外渗。这种"先算再调"的方式比盲试快得多，至少能让你从正确的量级开始。

彩色图换个思路，转到 L*a*b* 空间算欧氏距离。L 的范围是 0~100，a、b 是 -128~127，这个空间近似感知均匀，阈值 10~15 是个不错的起点。RGB 空间直接算距离我不推荐，因为 RGB 的距离和人眼感知差别太大，同一阈值在不同颜色上表现完全不一样。

2.3 种子点自动选取的几个实用招

如果种子只能手动点，区域生长就失去了批处理价值。我常用的自动选种思路有这么几种，按可靠性排序：

直方图峰值法。统计全图灰度直方图，找出主要的几个峰，每个峰对应的灰度值取一个代表像素当种子。这招在双峰明显的图上（背景+目标）特别好使，缺点是目标面积很小时峰不明显。

局部方差扫描法。把图分成 16×16 的小块，算每块的标准差，标准差小的块说明内部平坦，从中随机取点作种子。为了覆盖所有目标，我会同时保留每个连通平坦块的一个种子。这样做的好处是能自动长出多个区域，而不是只有一块。

梯度极小值法。计算梯度幅值图，找那些梯度接近 0 且周围一圈梯度也小的像素。这实际上是在找"区域中心"，比方差法更精细，但计算量稍大。

穷举法。对全图每个未标记像素依次尝试生长，最后按面积过滤掉太小的区域。最笨但最全面，图像不大的时候（比如 1024×1024 以内）完全可接受，只是耗时可能到秒级。

我在实际项目里的做法是：先用直方图峰值法快速看一眼数据分布，确认目标和背景是不是可分的；如果是，直接用峰值法自动选种；如果不可分，说明这张图本身就不适合区域生长，该换方法了。这个"先探测再决定"的步骤，能省掉大量无效调参时间。

2.4 一份可直接跑的区域生长实现

下面这段是我常用的版本，用广度优先搜索实现，避免深递归在 Python 里爆栈。核心逻辑是：用一个队列维护待处理像素，出队时更新区域均值，再检查它的邻居。

import numpy as np from collections import deque def region_grow(gray, seed, tol=8.0, conn=8, max_pixels=None): """ gray : 单通道图像，float 或 uint8 seed : (row, col) 种子坐标 tol : 相似性阈值 conn : 4 或 8 邻域 max_pixels: 面积上限，防止泄漏时无限扩张 """ h, w = gray.shape g = gray.astype(np.float32) mask = np.zeros((h, w), np.uint8) queued = np.zeros((h, w), bool) if conn == 8: nbrs = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)) else: nbrs = ((-1, 0), (1, 0), (0, -1), (0, 1)) sy, sx = seed if not (0 <= sy < h and 0 <= sx < w): raise ValueError("seed 越界") q = deque([(sy, sx)]) queued[sy, sx] = True total, count = 0.0, 0 while q: y, x = q.popleft() total += g[y, x] count += 1 mask[y, x] = 1 mean = total / count for dy, dx in nbrs: ny, nx = y + dy, x + dx if 0 <= ny < h and 0 <= nx < w and not queued[ny, nx]: if abs(g[ny, nx] - mean) <= tol: queued[ny, nx] = True q.append((ny, nx)) if max_pixels is not None and count >= max_pixels: break return mask

这段代码有三个地方值得单独说明。

第一，queued数组和mask数组是分开的。queued在入队时就置 True，防止同一个像素被多个邻居重复塞进队列，这能把队列长度控制在像素数量级。mask在出队时才置 1，这样万一触发max_pixels提前 break，已经入队但没处理的像素不会被算进结果，面积统计是准的。

第二，均值是边出队边更新的。注意这里是"出队顺序"更新，不是"入队顺序"，所以同一批入队的像素会影响后续像素的判据，但不会影响已经入队的那一批。如果你希望判据完全严格，可以改成"入队即更新"，代价是结果会更保守一些。

第三，用float32而不是原图类型做累加，避免 uint8 溢出。这个细节很多人都栽过——用 uint8 存total，加到 255 就回绕了，区域一大结果全乱。

性能上，纯 Python 循环处理 200 万像素大约要 1 到 2 秒，如果只是圈出 ROI 再裁剪成小图处理，可以降到几十毫秒。真要提速，两条路：一是用向量化的方式把整批像素一起判断，二是把循环部分交给编译型加速工具。我个人更倾向第一种，因为改起来简单、不引入额外依赖。

2.5 抑制泄漏的四个补丁

区域泄漏是我被问得最多的问题：明明目标边界挺清楚的，区域还是一路漏到背景里去了。原因通常是边界上有那么几个像素的灰度恰好落在阈值范围内，形成了一条"桥"。下面四个补丁按性价比排序，我一般先上第一个，不够再加。

补丁一：先做边缘保持的平滑。中值滤波或者双边滤波，把孤立的噪点干掉，同时保住边界。注意不要用大核高斯，5×5 以上就把边界糊掉了，边界一糊阈值再准也没用。

补丁二：加梯度门控。在生长时额外判断|∇I(ny,nx)| < G，梯度大的位置直接不许进。阈值 G 取全图梯度幅值的 70% 到 90% 分位数。这一招对"桥"的拦截效果非常直接，代价是边界细节可能被削掉一点。

补丁三：限制最大面积。我心里对目标尺度的量级有数，比如缺陷一般不超过全图 5%，那就把max_pixels设成 5%，超了直接截断。这不是精度优化，而是止损，防止一个坏种子拖垮整批处理。

补丁四：多尺度生长。先把图降采样一半再生长，得到粗略的区域轮廓，再把这个轮廓映射回原图作为掩膜，只在掩膜边缘一圈做精细生长。这样能避开原图上的小噪点，同时保留边界精度。这招稍复杂，但在噪声重的图上效果明显。

提醒一句：这四个补丁都只能缓解，不能根治。如果一张图上目标和背景的灰度重叠严重，区域生长本来就不是正解，别硬调，换个思路更省时间。

3. 分裂合并：把整图切碎再拼回来

分裂合并的思路很适合处理"我不知道目标在哪儿、也不知道有多大"的情况。它不需要种子，只要把"什么叫均匀"定义清楚，算法自己会把图切开再拼好。

3.1 四叉树分裂：切到什么时候停

最经典的分裂方式是四叉树：一个区域如果不够均匀，就横竖各切一刀，分成四块面积相等的子块，四块各自再判断。这个结构天然形成一棵树，父节点是整块，子节点是四分之一。

分裂的判据是"均匀性度量"超过阈值。常用的度量有三种：

• 标准差：std(patch) > T_s就切。最常用，对整体波动敏感。
• 极差：max - min > T_r就切。对孤立极值敏感，容易被一个噪点带偏。
• 区域内部梯度能量：mean(|∇I|) > T_g就切。能捕捉边界，但计算量稍大。

阈值怎么定，思路和区域生长类似。如果背景区域的标准差主要来自噪声，那T_s至少取 2.5 倍噪声标准差。继续用前面的例子，σ=3，T_s取 8 到 10。太小会导致过分割——连平坦背景都被切碎；太大则切不开，目标边界被粗块吞掉。

除了均匀性判据，还要设一个最小块尺寸。一般取目标最小尺寸的四分之一到一半。假如你的目标最小外接矩形是 16×16 像素，最小块就设 8 或 4。不设这个限制，递归会一直切到单像素，耗时爆炸，而且合并阶段也拼不回来。

这里必须诚实说一个局限性：四叉树只按 2 的幂次切分，边界一定落在网格线上，所以结果会带块状伪影，斜边和圆弧尤其明显。我在做尺寸测量时会明确告诉使用方这个误差范围，通常在半块到一块之间。如果测量精度要求高，得靠后面的合并阶段或者边缘细化来补。

3.2 合并阶段：邻接关系与合并准则

分裂完得到一堆碎块，接下来要把该在一起的拼回去。这一步的关键有两个：谁和谁相邻，以及相邻到什么时候可以合并。

邻接关系我用并查集维护。具体做法是扫描全图，对每个像素检查它右边和下边的邻居，如果两个像素属于不同区域，就把这对区域记下来，同时累加它们之间的边界长度。边界长度很重要，它决定了"这两个区域是不是真的贴着"，避免只有一两个像素接触的区域被误合并。

合并准则我一般用两条件同时成立：

1. 均值差小：|mean(A) - mean(B)| <= T_m。
2. 边界够长且边界处梯度弱：共同边界像素数超过最小长度（比如 8 个像素），且边界上的平均梯度幅值低于某个值。

第一个条件保证颜色像，第二个条件保证它们之间的分界不是真实边缘。只用第一个条件会出问题：两个不相邻的区域如果颜色碰巧相似，会被错误合并——这还算好的，更糟的是把一条细边两侧的同类区域合并，把真实边界抹掉。

T_m和T_s要配套。我一般取T_m为T_s的 1.5 到 2 倍。理由很直白：分裂时把标准差超过T_s的块切开了，合并时如果T_m比T_s还小，刚切开的块立刻又被合回去，等于白切。这个配套关系是很多人调不出来结果的根本原因。

3.3 完整流程伪代码与复杂度

把上面两步串起来，整体流程是这样的：

import numpy as np class DSU: def __init__(self, n): self.p = list(range(n)) def find(self, x): while self.p[x] != x: self.p[x] = self.p[self.p[x]] x = self.p[x] return x def union(self, a, b): ra, rb = self.find(a), self.find(b) if ra != rb: self.p[rb] = ra return True return False def split_merge(gray, th_std, th_mean, min_block, min_border=8): h, w = gray.shape g = gray.astype(np.float32) # 1) 填充到 2 的幂，方便四叉树切分 size = 1 while size < max(h, w): size *= 2 pad = np.full((size, size), g.mean(), np.float32) pad[:h, :w] = g label = np.full((size, size), -1, np.int32) counter = [0] # 2) 递归分裂 def split(y, x, s): patch = pad[y:y+s, x:x+s] if s <= min_block or patch.std() <= th_std: label[y:y+s, x:x+s] = counter[0] counter[0] += 1 return half = s // 2 split(y, x, half) split(y, x+half, half) split(y+half, x, half) split(y+half, x+half, half) split(0, 0, size) # 3) 统计区域均值和边界 n = counter[0] sums = np.bincount(label.ravel(), weights=pad.ravel(), minlength=n) cnts = np.bincount(label.ravel(), minlength=n).astype(np.float32) means = sums / np.maximum(cnts, 1) border_len = np.zeros((n, n), np.int32) for dz in (np.s_[:, :-1], np.s_[:-1, :]): a = label[dz] b = label[np.s_[:, 1:]] if dz == np.s_[:, :-1] else label[np.s_[1:, :]] diff = a != b for u, v in zip(a[diff].ravel(), b[diff].ravel()): border_len[u, v] += 1 border_len[v, u] += 1 # 4) 合并 dsu = DSU(n) pairs = [(border_len[i, j], i, j) for i in range(n) for j in range(i+1, n) if border_len[i, j] >= min_border] for _, i, j in sorted(pairs, key=lambda t: abs(means[t[1]] - means[t[2]])): ri, rj = dsu.find(i), dsu.find(j) if ri == rj: continue if abs(means[ri] - means[rj]) <= th_mean: dsu.union(ri, rj) # 5) 还原标签 roots = np.array([dsu.find(i) for i in range(n)]) out = roots[label] return out[:h, :w]

复杂度方面：分裂阶段每一层处理全部像素一次，树深度是 log₂(size/min_block)，所以是 O(N log S)。合并阶段先扫两遍全图建边界表，复杂度 O(N)，再对候选对排序，数量级是区域数的平方，实际区域数通常几百到几千，排序开销可以忽略。整体比纯区域生长慢，但在 200 万像素的图上，Python 实现一般也就几秒。

上面这段代码为了可读性省掉了两个边界检查：一是填充区域参与统计会影响均值，二是label为 -1 的位置（理论上不会有）需要处理。真拿去用的话，建议在区域统计时用掩膜排除填充部分，或者在填充时用一个明确的"无效标签"并在合并时跳过。

3.4 改进方向：非均匀切分与边界约束

四叉树的块状伪影确实让人难受，我试过几个改法，按投入产出比排一下：

改法一：合并阶段允许小区域被大区域吞并。面积小于某阈值的碎块，如果和邻居均值差在 1.5 倍T_m以内，直接并进去。这能削掉大部分块状感，因为伪影往往就是那些边角碎块。

改法二：按最大方差方向二分，而不是四等分。对每个区域，计算行方向和列方向的方差，往方差大的方向切一刀。这样切出来的边界更贴合实际结构，深度也浅一些。代价是区域不再是标准四叉树，邻接关系要重新建。

改法三：把边缘图作为硬约束。先用边缘检测得到强边缘，合并时如果两个区域的共同边界和强边缘重合度超过某个比例，就禁止合并。这一条对"两个目标紧挨着但属于不同物体"的场景特别关键，否则一定粘在一起。

改法四：和区域生长杂交。用分裂合并先得到粗分割，把每个区域的中心当作种子，回头用区域生长在原始灰度图上精细生长一遍。粗分割保证了不会漏目标，精细生长保证了边界贴合。这个组合我在几个项目里用下来最省心，代价是要调两套参数。

4. 从一张图到可用掩膜：参数标定与实操流程

算法本身不难，难的是把一张真实图像变成一张能用的掩膜。这一节我按实际项目的推进顺序讲：预处理怎么处理，参数怎么标定，后处理怎么收尾，最后给一段完整的流程记录。

4.1 预处理：光照、噪声、梯度

预处理做不好，后面所有参数都是白调。我按优先级排三件事。

光照不均。这是工业图最常见的毛病，中间亮四周暗，或者有条纹。两种处理方式：一是顶帽变换（开运算减原图），适合目标比背景亮且目标较小的场景；二是局部均值归一化，用大核均值滤波得到背景估计，原图减去它。后者更通用，核大小取目标尺寸的 3 到 5 倍。

噪声。中值滤波 3×3 对付椒盐噪声，双边滤波对付一般的高斯噪声。这里有个取舍：滤波越强，泄漏越少，但边界越糊，边界一糊分割精度就掉。我的经验是宁可弱一点，把抗泄漏交给梯度门控，而不是靠滤波硬压。

梯度图。用 Sobel 或者 Scharr 算子算一次梯度幅值，后面区域生长做门控、分裂合并做边界约束都要用。这一步几乎零成本，但对结果的改善很大，我建议每次都算。

顺带说一个我踩过的坑：不要在处理过程中反复在 uint8 和 float 之间来回转。每转一次都有量化误差，转个四五次之后边界就出现阶梯了。正确做法是一进流程就转 float32，全程用 float 算，只在最后输出掩膜时转回 uint8。

4.2 阈值标定：用数据说话

阈值不能拍脑袋，但也不用搞得很复杂。我的做法是准备 20 到 50 张有代表性的图，人工标注或者用可靠的半自动方式得到参考掩膜，然后扫一遍参数，算 IoU，画曲线。

一个提醒：不要在一张图上把参数调到完美，那样一定过拟合。我通常的做法是把样本分成两组，一组调参、一组验证，验证组的 IoU 掉超过 10 个点就说明参数太激进，往回收一收。

还有个小技巧：先用最大类间方差法（大津法）给你一个初始阈值，虽然它假设双峰分布、在复杂图上不一定准，但作为一个起点比从零开始试要快得多。我会在大津法给出的阈值上下各取 50% 的范围扫一圈，通常能很快找到合适的位置。

4.3 后处理：形态学与连通域过滤

算法出来的掩膜几乎没有能直接用的时候，后处理是必需的。我常用的四步：

1. 开运算去小突起，核 3×3，一次就够，多了会把细长目标削断。
2. 闭运算补小孔，同样 3×3。
3. 孔洞填充，从边界做一次填充，把内部空洞补上。这一步对"目标内部有反光点"的场景特别有用。
4. 连通域过滤，统计每个连通域的面积，小于下限的丢掉（噪点），大于上限的也丢掉（泄漏）。

第 4 步的下限怎么定？按目标的最小可能面积算，打个七折。比如最小缺陷面积 200 像素，下限设 140。上限按最大可能面积算，翻一倍。这两个数字最好从业务方那里问来，比自己猜靠谱得多。

4.4 一次完整的流程记录

前段时间处理的一批图，是某种金属件的表面缺陷检测。图像 2048×1536，8 位灰度，缺陷是暗色斑块，面积 300 到 3000 像素不等，背景有大面积的加工纹理。完整流程和参数如下。

第一步，预处理。局部均值归一化，核 101×101，消除照明不均。3×3 中值滤波去噪。转 float32。

第二步，粗定位。因为缺陷是暗斑，先用大津法得到一个全局阈值，把所有可能的目标区域圈出来，形态学膨胀 5 像素，作为 ROI 掩膜。这一步很快，主要作用是把后续计算的区域缩小到 20% 左右。

第三步，区域生长。在 ROI 内，取梯度幅值最小的 30 个点作为种子，tol=9，8 邻域，max_pixels=5000，梯度门控阈值取全图梯度 80% 分位数。种子之间如果长到一起，用连通域分开。

第四步，分裂合并补漏。在 ROI 内跑一遍分裂合并，th_std=10，th_mean=18，min_block=8，min_border=10。把结果和第三步的掩膜做并集，防止某些低对比度缺陷被漏掉。

第五步，后处理。开运算 3×3，闭运算 3×3，孔洞填充，连通域面积过滤 [140, 6000]。

结果。一批 200 张图，人工标注的缺陷 IoU 平均 0.78，单张耗时约 240 毫秒（其中区域生长 90 毫秒，分裂合并 120 毫秒，预处理和后处理 30 毫秒）。漏检 3 张，都是对比度极低的浅划痕，后来单独加了一条基于方向滤波的检测通道才解决。

这个案例里最值得说的经验是：两种算法做并集，比任何一个单独调到最优都强。区域生长贴边好，分裂合并漏检少，并起来刚好互补。代价是参数量翻倍，但对一个要长期跑的项目来说，这点维护成本完全可以接受。

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

这一段我按"症状 → 可能原因 → 对策"的方式来写，都是实际项目里反复遇到的。

5.1 区域泄漏、过分割、欠分割

区域泄漏是区域生长最常见的失败。症状是掩膜从目标边缘伸出一条"尾巴"，或者直接糊满整个背景。原因有三个：阈值太大、边界处有灰度桥、没有面积上限。排查顺序我建议从阈值开始，把tol砍一半看看还漏不漏；如果砍了不漏但目标也变小了，说明是边界对比度不够，得上梯度门控；如果加了门控还漏，那就是真有灰度桥，得回头改预处理，比如加强局部对比度。

过分割在分裂合并里特别常见。症状是同一块目标被切成十几块，合并不回去。原因通常是th_std太小，或者th_mean比th_std还小。先检查th_mean是否满足 1.5 倍th_std的关系，不满足先调这个；满足还过分割，就把th_std往上抬一档。另一个隐蔽原因是min_border设太大了，导致本来该合并的相邻区域因为边界太短被跳过，检查一下边界长度分布就知道。

欠分割正好相反，两个目标粘成一块。原因可能是th_mean太大，也可能是两个目标之间本来就没有明显边界。前者调小阈值；后者得引入额外约束，比如在合并时判断共同边界处有没有强边缘，有就不许合。

5.2 速度慢和内存爆

纯 Python 实现的区域生长在 200 万像素上跑 1 到 2 秒，如果一批有上千张图，这个时间就很要命了。我常用的提速手段按效果排序：

先裁 ROI。这是最有效的，往往能砍掉 70% 以上的计算量。前提是你有一个便宜的粗定位方法，比如全局阈值、投影分析、或者降采样后的粗略检测。

降采样。先把图缩小 4 倍跑一遍，得到大致轮廓，再把轮廓放大回原图，只在轮廓附近 10 像素的带内做精细生长。精度几乎不掉，速度快好几倍。

换数据结构。用固定大小的环形缓冲替代deque，用一维数组替代二维坐标元组，能省 20% 左右。收益不算大，但改动很小。

内存方面，分裂合并要注意递归深度和标签图大小。递归深度是 log₂(size/min_block)，一般不超过 15，问题不大。标签图用 int32 存，200 万像素就是 8MB，加上中间的边界表，如果区域数上千，边界表是 n×n 的，很容易爆。我的处理方式是不用稠密矩阵存边界，改用字典，只存实际存在的邻接对，内存立刻降下来。

5.3 问题速查表

最后再补两个不太容易想到的经验。

第一，参数不是越精确越好。我曾经花了两天把某批图的阈值调到 IoU 0.91，结果换了一批来料直接掉到 0.6。后来复盘发现是那批图的曝光设置变了。从此我的做法是：参数按"图像统计量"来定，而不是按"绝对数值"来定。比如阈值不写死 9，而是写成2.8 * 噪声标准差，这样换一批图时它能自己适应。

第二，永远保留一个可视化中间结果的开关。种子点在哪、梯度图长什么样、分裂后的块有多少、合并前后的区域数变化，这些信息在调试时极其宝贵。我习惯在代码里加一个debug=True参数，打开就把这些中间图存到本地目录，出问题时翻一翻，比盯着最终掩膜猜要快十倍。

我个人在实际项目里的体会是，这两种算法真正的价值不在于算法本身有多精妙——它们的原理简单到一页纸就能写完——而在于它们给了你一个可以逐层拆解、每一层都能看懂的过程。深度学习给你一个黑箱和一堆需要调的超参，出问题时你只能换数据、换模型、加正则。而区域生长和分裂合并不一样，掩膜糊了，你能明确知道是种子选偏了还是阈值放大了，能一层层往回找。这种可控性，在需要长期维护、需要向非技术方解释结果的项目里，往往比多几个点的精度更值钱。