OpenCV中实现Blob外边缘到内边缘的直线绘制（解决拐角点线条偏差问题）

你好呀！看了你遇到的问题：你手里有一个由内外两层边缘构成的不规则Blob，想要绘制从外边缘到内边缘的垂直连线，预期是均匀、贴合边缘法线方向的线条，但目前用邻域点求斜率的方法在拐角处失效，画出的线条偏差很大。

先回顾一下你已经完成的步骤，思路是对的：先用Canny提取边缘，再用cv2.connectedComponents()拆分出内外边缘，代码如下：

import cv2
import numpy as np
from collections import defaultdict

originalimage = cv2.imread(R"blob.png")
edge = cv2.Canny(originalimage, 100, 200)

def get_islands(img):
    n, labels = cv2.connectedComponents(img.astype(np.uint8))
    islands = [(labels == i).astype(np.uint8) for i in range(1, n)]
    return islands

edge_sets = get_islands(edge)
inner = edge_sets[1]
outer = edge_sets[0]

之后你尝试构建边缘点的邻接图，通过邻域点计算斜率再求垂线，但这种方法的问题在于：拐角处的邻域点来自不同方向，平均后的斜率完全不是边缘的实际切线方向，自然垂线就会跑偏。

下面给你两种更稳健的改进方案，能很好解决拐角点的偏差问题：

方案一：基于距离变换的最短路径连线 #

这种方法的核心是利用距离变换直接获取每个点到内边缘的最短路径方向，外边缘点沿着这个方向移动就能精准找到对应的内边缘点，完全不需要计算斜率，对拐角和不规则边缘都很友好。

实现步骤： #

1. 以内边缘为参考，生成距离变换图和方向图，方向图会告诉每个点到最近内边缘点的移动方向
2. 遍历外边缘点，沿着方向图指示的方向移动，直到碰到内边缘，然后绘制这条直线

代码示例： #

import cv2
import numpy as np

originalimage = cv2.imread("blob.png", 0)
edge = cv2.Canny(originalimage, 100, 200)

def get_islands(img):
    n, labels = cv2.connectedComponents(img.astype(np.uint8))
    islands = [(labels == i).astype(np.uint8)*255 for i in range(1, n)]
    return islands

edge_sets = get_islands(edge)
inner = edge_sets[1]
outer = edge_sets[0]

# 生成距离变换图和方向标签图（方向用0-7的索引表示8个邻域方向）
dist_transform, dir_labels = cv2.distanceTransformWithLabels(255 - inner, cv2.DIST_L2, 5)
# 把方向索引转换成对应的坐标偏移量
direction_offsets = [(-1,-1), (-1,0), (-1,1), (0,1), (1,1), (1,0), (1,-1), (0,-1)]

line_image = cv2.cvtColor(originalimage, cv2.COLOR_GRAY2RGB)
# 获取所有外边缘点的坐标
outer_points = np.nonzero(outer)
outer_points = list(zip(outer_points[0], outer_points[1]))

# 每隔N个点绘制一条线，避免线条过密（可根据你的需求调整step值）
step = 50
for idx, (x, y) in enumerate(outer_points):
    if idx % step != 0:
        continue
    # 获取当前点指向内边缘的方向
    dir_idx = dir_labels[x, y]
    dx, dy = direction_offsets[dir_idx]
    current_x, current_y = x, y
    # 沿着方向移动，直到找到内边缘点
    while True:
        current_x += dx
        current_y += dy
        # 边界判断
        if current_x < 0 or current_x >= originalimage.shape[0] or current_y <0 or current_y >= originalimage.shape[1]:
            break
        # 检测是否到达内边缘
        if inner[current_x, current_y] == 255:
            cv2.line(line_image, (y, x), (current_y, current_x), (255, 0, 0), 3)
            break

# 展示结果
cv2.imshow("Final Result", line_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

方案二：基于轮廓平滑拟合的法线连线 #

如果希望线条严格垂直于边缘的切线方向，可以先对内外轮廓进行平滑拟合，过滤局部噪声后，计算轮廓上每个点的法线方向，再向内寻找对应的内轮廓点。

实现步骤： #

1. 用cv2.findContours()提取内外边缘的轮廓
2. 用多边形拟合或B样条拟合对轮廓进行平滑处理
3. 计算平滑后外轮廓点的法线方向，沿着法线方向找到最近的内轮廓点并绘制直线

代码示例： #

import cv2
import numpy as np

originalimage = cv2.imread("blob.png", 0)
edge = cv2.Canny(originalimage, 100, 200)

# 提取内外轮廓（RETR_EXTERNAL可能需要调整为RETR_TREE，根据你的边缘层级）
contours, hierarchy = cv2.findContours(edge, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
# 假设外层轮廓是第一个，内层是第二个（可根据hierarchy判断层级）
outer_contour = contours[0]
inner_contour = contours[1]

# 对轮廓进行平滑拟合，epsilon值越小拟合越接近原轮廓，越大越平滑
epsilon_outer = 0.001 * cv2.arcLength(outer_contour, True)
smooth_outer = cv2.approxPolyDP(outer_contour, epsilon_outer, True)
epsilon_inner = 0.001 * cv2.arcLength(inner_contour, True)
smooth_inner = cv2.approxPolyDP(inner_contour, epsilon_inner, True)

line_image = cv2.cvtColor(originalimage, cv2.COLOR_GRAY2RGB)

# 每隔N个点绘制一条线
step = 10
for i in range(0, len(smooth_outer), step):
    # 获取当前外轮廓点
    outer_p = smooth_outer[i][0]
    ox, oy = outer_p[0], outer_p[1]
    # 通过前后点计算切线方向
    prev_idx = (i - 1) % len(smooth_outer)
    next_idx = (i + 1) % len(smooth_outer)
    prev_p = smooth_outer[prev_idx][0]
    next_p = smooth_outer[next_idx][0]
    # 切线向量
    tx = next_p[0] - prev_p[0]
    ty = next_p[1] - prev_p[1]
    # 法线向量（向内，这里取垂直于切线的方向，可根据实际情况调整正负）
    nx = -ty
    ny = tx
    # 归一化法线
    norm = np.sqrt(nx**2 + ny**2)
    if norm == 0:
        continue
    nx /= norm
    ny /= norm

    # 寻找法线方向上最近的内轮廓点
    min_dist = float('inf')
    best_inner_p = None
    for inner_p in smooth_inner:
        ip = inner_p[0]
        # 计算距离
        dist = np.sqrt((ip[0]-ox)**2 + (ip[1]-oy)**2)
        # 检查是否在法线方向上（点积为正表示在法线指向的一侧）
        dot_product = (ip[0]-ox)*nx + (ip[1]-oy)*ny
        if dot_product > 0 and dist < min_dist:
            min_dist = dist
            best_inner_p = ip
    # 绘制直线
    if best_inner_p is not None:
        cv2.line(line_image, (ox, oy), (best_inner_p[0], best_inner_p[1]), (255, 0, 0), 3)

# 展示结果
cv2.imshow("Final Result", line_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

这两种方法都能有效解决你遇到的拐角点线条偏差问题：方案一更简单直接，适合追求精准连线的场景；方案二更贴合边缘的法线方向，适合需要严格垂直边缘的需求。

备注：内容来源于stack exchange，提问作者let me down slowly