我完全懂你现在的困扰——Lang算法处理尖峰确实有效，但它的全局阈值逻辑很容易把轮廓上关键的角部倒角、特征点也一并平滑掉，导致轮廓失去原本的结构信息。针对这个问题，我整理了几个更精准的解决方案，既可以剔除冗余的尖峰噪声，又能牢牢保留重要的特征点：

1. 曲率引导的局部平滑法 #

核心思路是先识别高曲率的特征点（角点），只对低曲率的平滑区域做降噪处理，这样就能精准区分“尖峰噪声”和“有用特征”。

实现步骤： #

• 计算轮廓每个点的曲率，曲率越高说明这个点越可能是角部特征；
• 设定曲率阈值，保留曲率高于阈值的点；
• 对曲率低于阈值的连续区域，用滑动平均或高斯平滑来剔除尖峰。

代码示例： #

import numpy as np

def calculate_curvature(contour):
    # 计算轮廓点的曲率（闭环处理）
    n = len(contour)
    curvature = np.zeros(n)
    for i in range(n):
        prev = contour[(i-1) % n][0]
        curr = contour[i][0]
        next_p = contour[(i+1) % n][0]
        
        # 用向量叉乘计算曲率近似值
        vec1 = prev - curr
        vec2 = next_p - curr
        cross = np.cross(vec1, vec2)
        norm = np.linalg.norm(vec1) * np.linalg.norm(vec2)
        if norm != 0:
            curvature[i] = abs(cross) / (norm ** 1.5)
    return curvature

def smooth_contour_with_curvature(contour, curvature_threshold=0.01, smooth_window=3):
    curvature = calculate_curvature(contour)
    smoothed = contour.copy()
    
    # 只平滑低曲率区域
    n = len(contour)
    for i in range(n):
        if curvature[i] < curvature_threshold:
            # 滑动平均平滑
            window_indices = [(i + j) % n for j in range(-smooth_window//2, smooth_window//2+1)]
            window_points = contour[window_indices][:,0]
            smoothed[i][0] = np.mean(window_points, axis=0).astype(int)
    
    # 强制保留高曲率的特征点
    mask = curvature >= curvature_threshold
    smoothed[mask] = contour[mask]
    
    return smoothed

2. 带特征点约束的Ramer-Douglas-Peucker（RDP）算法 #

经典的RDP算法通过递归删除距离拟合线段最近的点简化轮廓，但我们可以给它加特征点保护机制：

• 先通过角点检测（比如Shi-Tomasi或Harris角点）标记出轮廓上的关键特征点；
• 在RDP简化过程中，强制保留这些标记点，只对非标记区域做简化。

代码示例： #

def point_line_distance(x, y, x1, y1, x2, y2):
    # 计算点到线段的距离
    numerator = abs((y2 - y1)*x - (x2 - x1)*y + x2*y1 - y2*x1)
    denominator = np.sqrt((y2 - y1)**2 + (x2 - x1)**2)
    return numerator / denominator if denominator != 0 else 0

def rdp_with_constraints(contour, epsilon, constraint_points):
    # 将约束点转为轮廓索引集合
    constraint_indices = set()
    for p in constraint_points:
        idx = np.argmin(np.linalg.norm(contour[:,0] - p, axis=1))
        constraint_indices.add(idx)
    
    def rdp_recursive(points, start, end):
        if end - start <= 1:
            return [start, end]
        # 找到距离线段最远的点（跳过约束点）
        line_start = points[start][0]
        line_end = points[end][0]
        max_dist = 0
        farthest_idx = start
        for i in range(start+1, end):
            if i in constraint_indices:
                continue
            dist = point_line_distance(points[i][0][0], points[i][0][1],
                                      line_start[0], line_start[1],
                                      line_end[0], line_end[1])
            if dist > max_dist:
                max_dist = dist
                farthest_idx = i
        if max_dist > epsilon:
            left = rdp_recursive(points, start, farthest_idx)
            right = rdp_recursive(points, farthest_idx, end)
            return left[:-1] + right
        else:
            # 保留当前段内的所有约束点
            segment_indices = [start, end]
            for i in range(start+1, end):
                if i in constraint_indices:
                    segment_indices.append(i)
            return sorted(segment_indices)
    
    # 处理闭环轮廓
    indices = rdp_recursive(contour, 0, len(contour)-1)
    if indices[0] != indices[-1]:
        indices.append(indices[0])
    return contour[indices]

# 先检测约束点（用Harris角点示例）
import cv2
gray = np.zeros((2048, 2048), dtype=np.uint8)
cv2.drawContours(gray, [contour], 0, 255, 1)
corners = cv2.cornerHarris(gray, 2, 3, 0.04)
corner_y, corner_x = np.where(corners > 0.01 * corners.max())
constraint_points = np.array([[corner_x[i], corner_y[i]] for i in range(len(corner_x))])

# 应用带约束的RDP
smoothed_contour = rdp_with_constraints(contour, epsilon=2, constraint_points=constraint_points)

3. 针对示例轮廓的预处理建议 #

你的示例轮廓里有很多连续的重复/近重复点（比如[[473,1665]],[[473,1666]]），先做点云去重可以减少计算量，同时提升后续平滑的效果：

# 去重连续重复点
unique_contour = []
prev_point = None
for p in contour:
    if prev_point is None or not np.array_equal(p[0], prev_point):
        unique_contour.append(p)
        prev_point = p[0]
unique_contour = np.array(unique_contour)

内容的提问来源于stack exchange，提问作者tabula_rasa