基于受损2D轮廓信息的多边形（最多八边形）拟合方案咨询

针对破损、中空的2D轮廓，OpenCV常规轮廓检测函数效果不佳时，可采用以下几种鲁棒性解决方案，支持C++和Python实现：

1. RANSAC鲁棒多边形拟合 #

利用RANSAC的抗噪特性，从破损轮廓点集中迭代拟合出最优的八边形模型，自动排除截断区域的无效点。

Python实现示例 #

import cv2
import numpy as np
from sklearn.linear_model import RANSACRegressor

def fit_octagon_ransac(contour_points, max_iter=1000, error_thresh=5):
    octagon_vertices = []
    remaining_points = contour_points.copy()
    
    for _ in range(8):
        if len(remaining_points) < 2:
            break
        # RANSAC拟合直线
        X = remaining_points[:, 0].reshape(-1,1)
        y = remaining_points[:, 1]
        ransac = RANSACRegressor(residual_threshold=error_thresh, max_trials=max_iter)
        ransac.fit(X, y)
        inlier_mask = ransac.inlier_mask_
        
        # 提取直线端点作为顶点候选
        x_min, x_max = remaining_points[inlier_mask][:,0].min(), remaining_points[inlier_mask][:,0].max()
        y_min = ransac.predict([[x_min]])[0]
        y_max = ransac.predict([[x_max]])[0]
        octagon_vertices.extend([(x_min, y_min), (x_max, y_max)])
        
        # 移除已拟合的内点
        remaining_points = remaining_points[~inlier_mask]
    
    # 去重并按中心角度排序顶点，形成闭合八边形
    octagon_vertices = np.unique(np.array(octagon_vertices), axis=0)
    if len(octagon_vertices) > 8:
        octagon_vertices = octagon_vertices[:8]
    center = np.mean(octagon_vertices, axis=0)
    angles = np.arctan2(octagon_vertices[:,1]-center[1], octagon_vertices[:,0]-center[0])
    octagon_vertices = octagon_vertices[np.argsort(angles)]
    return np.array(octagon_vertices, dtype=np.int32)

# 加载图像并提取轮廓点
img = cv2.imread("input.jpg", 0)
_, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contour_points = np.vstack(contours).squeeze()

# 拟合并绘制八边形
octagon = fit_octagon_ransac(contour_points)
output_img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
cv2.polylines(output_img, [octagon], isClosed=True, color=(0,255,0), thickness=2)
cv2.imwrite("output.jpg", output_img)

C++实现示例 #

#include <opencv2/opencv.hpp>
#include <vector>
#include <random>
#include <algorithm>

using namespace cv;
using namespace std;

vector<Point2f> fitOctagonRANSAC(vector<Point2f>& points, int maxIter = 1000, float errorThresh = 5.0f) {
    vector<Point2f> octagonVertices;
    vector<Point2f> remainingPoints = points;

    for (int i = 0; i < 8; ++i) {
        if (remainingPoints.size() < 2) break;

        // RANSAC迭代拟合最优直线
        int bestInliers = 0;
        Vec4f bestLine;
        default_random_engine rng;
        uniform_int_distribution<int> dist(0, (int)remainingPoints.size()-1);

        for (int iter = 0; iter < maxIter; ++iter) {
            int idx1 = dist(rng), idx2 = dist(rng);
            while (idx1 == idx2) idx2 = dist(rng);
            Point2f p1 = remainingPoints[idx1], p2 = remainingPoints[idx2];

            // 计算直线方程 ax + by + c = 0
            float a = p2.y - p1.y;
            float b = p1.x - p2.x;
            float c = p2.x*p1.y - p1.x*p2.y;

            // 统计内点数量
            int inliers = 0;
            for (auto& p : remainingPoints) {
                float dist = fabs(a*p.x + b*p.y + c) / sqrt(a*a + b*b);
                if (dist < errorThresh) inliers++;
            }

            if (inliers > bestInliers) {
                bestInliers = inliers;
                bestLine = Vec4f(p1.x, p1.y, p2.x, p2.y);
            }
        }

        // 提取内点并移除
        vector<Point2f> newRemaining, inlierPoints;
        float a = bestLine[3] - bestLine[1];
        float b = bestLine[0] - bestLine[2];
        float c = bestLine[2]*bestLine[1] - bestLine[0]*bestLine[3];
        for (auto& p : remainingPoints) {
            float dist = fabs(a*p.x + b*p.y + c) / sqrt(a*a + b*b);
            dist < errorThresh ? inlierPoints.push_back(p) : newRemaining.push_back(p);
        }

        // 提取直线端点作为顶点
        float minX = FLT_MAX, maxX = FLT_MIN;
        for (auto& p : inlierPoints) {
            minX = min(minX, p.x);
            maxX = max(maxX, p.x);
        }
        float yMin = (-a*minX - c)/b;
        float yMax = (-a*maxX - c)/b;
        octagonVertices.emplace_back(minX, yMin);
        octagonVertices.emplace_back(maxX, yMax);
        remainingPoints = newRemaining;
    }

    // 去重并按中心角度排序顶点
    sort(octagonVertices.begin(), octagonVertices.end());
    auto last = unique(octagonVertices.begin(), octagonVertices.end());
    octagonVertices.erase(last, octagonVertices.end());
    if (octagonVertices.size() > 8) octagonVertices.resize(8);

    Point2f center(0,0);
    for (auto& p : octagonVertices) center += p;
    center /= octagonVertices.size();
    sort(octagonVertices.begin(), octagonVertices.end(), [center](const Point2f& a, const Point2f& b) {
        return atan2(a.y - center.y, a.x - center.x) < atan2(b.y - center.y, b.x - center.x);
    });

    return octagonVertices;
}

int main() {
    Mat img = imread("input.jpg", IMREAD_GRAYSCALE);
    Mat binary;
    threshold(img, binary, 127, 255, THRESH_BINARY_INV);
    vector<vector<Point>> contours;
    findContours(binary, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

    vector<Point2f> contourPoints;
    for (auto& cnt : contours)
        for (auto& p : cnt) contourPoints.emplace_back(p);

    vector<Point2f> octagon = fitOctagonRANSAC(contourPoints);
    vector<Point> octagonInt;
    for (auto& p : octagon) octagonInt.emplace_back(cvRound(p.x), cvRound(p.y));

    Mat output = img.clone();
    cvtColor(output, output, COLOR_GRAY2BGR);
    polylines(output, octagonInt, true, Scalar(0,255,0), 2);
    imwrite("output.jpg", output);

    return 0;
}

2. 主动轮廓（Snake）修复+多边形拟合 #

先用Snake模型修复破损轮廓，使其形成连续闭合曲线，再用approxPolyDP进行多边形拟合，限制顶点数不超过8。

Python实现示例 #

import cv2
import numpy as np

def snake_contour_repair(img, init_contour, alpha=0.015, beta=10, gamma=0.001):
    snake = init_contour.astype(np.float32)
    # 迭代更新Snake轮廓
    for _ in range(500):
        # 计算内部平滑能量
        dx = np.diff(snake[:,0], append=snake[0,0])
        dy = np.diff(snake[:,1], append=snake[0,1])
        ddx = np.diff(dx, append=dx[0])
        ddy = np.diff(dy, append=dy[0])
        internal = alpha * (ddx**2 + ddy**2) + beta * (dx**2 + dy**2)
        
        # 计算外部图像梯度能量
        grad_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
        grad_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)
        grad_mag = np.sqrt(grad_x**2 + grad_y**2)
        external = -gamma * grad_mag[snake[:,1].astype(int), snake[:,0].astype(int)]
        
        # 更新轮廓点
        energy = internal + external
        snake += 0.1 * np.gradient(-energy)
        snake = np.clip(snake, 0, np.array(img.shape[::-1])-1)
    return snake.astype(np.int32)

# 加载图像并提取初始轮廓
img = cv2.imread("input.jpg", 0)
_, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
init_contour = np.vstack(contours).squeeze()

# 修复轮廓并拟合八边形
repaired_contour = snake_contour_repair(img, init_contour)
epsilon = 0.02 * cv2.arcLength(repaired_contour, True)
octagon = cv2.approxPolyDP(repaired_contour, epsilon, True)

# 调整epsilon使顶点数不超过8
while len(octagon) > 8:
    epsilon += 0.005 * cv2.arcLength(repaired_contour, True)
    octagon = cv2.approxPolyDP(repaired_contour, epsilon, True)

# 绘制结果
output_img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
cv2.polylines(output_img, [octagon], isClosed=True, color=(0,255,0), thickness=2)
cv2.imwrite("output.jpg", output_img)

3. 凸包迭代裁剪法 #

先提取轮廓点的凸包，反复裁剪凸包的"最尖锐"角点，直到顶点数降至8个以内，适合近似凸形的破损轮廓。

Python实现示例 #

import cv2
import numpy as np

def clip_convex_hull_to_octagon(convex_hull):
    hull = convex_hull.copy()
    while len(hull) > 8:
        # 计算每个角点的内角
        angles = []
        n = len(hull)
        for i in range(n):
            p_prev = hull[(i-1)%n][0]
            p_curr = hull[i][0]
            p_next = hull[(i+1)%n][0]
            vec1 = p_prev - p_curr
            vec2 = p_next - p_curr
            angle = np.arccos(np.dot(vec1, vec2)/(np.linalg.norm(vec1)*np.linalg.norm(vec2)))
            angles.append(angle)
        # 移除最小内角的点（最尖锐的角）
        min_idx = np.argmin(angles)
        hull = np.delete(hull, min_idx, axis=0)
    return hull

# 加载图像并提取凸包
img = cv2.imread("input.jpg", 0)
_, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contour_points = np.vstack(contours).squeeze()
convex_hull = cv2.convexHull(contour_points)

# 裁剪为八边形并绘制
octagon = clip_convex_hull_to_octagon(convex_hull)
output_img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
cv2.polylines(output_img, [octagon], isClosed=True, color=(0,255,0), thickness=2)
cv2.imwrite("output.jpg", output_img)

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