我之前在做实时卡片透视变换的时候，也碰到过和你一模一样的问题——静态图里用简单算法能凑活，但一到实时帧，卡片旋转、轻微晃动就直接失效。后来摸索出几个简单又鲁棒的方法，亲测在各种状态下都能稳定抓到四个顶点，给你分享一下：

第一步：预处理+轮廓筛选，锁定卡片候选 #

先给实时帧做降噪和边缘强化，再精准筛选出卡片的轮廓：

• 对帧做灰度化→高斯模糊→Canny边缘检测，这三步能有效过滤环境噪声，让卡片的边缘更清晰。
• 用findContours提取所有轮廓后，先按面积从大到小排序，取前5个候选（卡片一般是画面中面积较大的物体），过滤掉面积过小的杂轮廓。
• 对每个候选轮廓用approxPolyDP做多边形逼近，设置epsilon为轮廓周长的0.02倍（可根据实际场景微调），筛选出逼近后顶点数为4的轮廓——这就是卡片的初步候选。

第二步：验证轮廓合理性，避免误判 #

光有4个顶点还不够，得确保这是符合卡片特征的四边形：

• 用isContourConvex判断轮廓是否为凸形，卡片几乎都是凸四边形，非凸的直接排除。
• 计算四边形的两条对角线长度，设置容错阈值（比如对角线长度差不超过10%），因为矩形的对角线长度基本相等，这能有效过滤掉类似4顶点的不规则杂形。

第三步：顶点排序，适配透视变换要求 #

getPerspectiveTransform要求输入的顶点是有序的（比如左上→右上→右下→左下的固定顺序），否则变换后的图像会错乱。这里有个超实用的排序方法，旋转状态下也能精准区分：

1. 计算四个顶点的x+y值：x+y最小的是左上顶点，x+y最大的是右下顶点。
2. 计算四个顶点的x-y值：x-y最小的是右上顶点，x-y最大的是左下顶点。
   用这个方法排序后，不管卡片怎么转，顶点顺序都能符合透视变换的要求。

第四步：实时优化，提升稳定性 #

针对实时场景的抖动问题，再加两个小技巧：

• 帧间跟踪：如果上一帧成功检测到了卡片顶点，这一帧可以只在顶点周围的小区域内搜索轮廓，不用全图检测，既能减少计算量，又能避免丢失目标。
• 坐标平滑：把连续几帧的顶点坐标做加权平均（比如当前帧坐标=0.7当前检测值+0.3上一帧值），能有效降低实时检测的抖动。

核心代码片段（Python+OpenCV） #

import cv2
import numpy as np

def order_card_vertices(pts):
    # 按左上→右上→右下→左下的顺序排列顶点
    rect = np.zeros((4, 2), dtype="float32")
    
    # x+y最小=左上，x+y最大=右下
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]
    rect[2] = pts[np.argmax(s)]
    
    # x-y最小=右上，x-y最大=左下
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)]
    rect[3] = pts[np.argmax(diff)]
    
    return rect

def detect_card(frame):
    # 预处理
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    edged = cv2.Canny(blurred, 50, 150)
    
    # 提取并筛选轮廓
    contours, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
    
    card_pts = None
    for c in contours:
        perimeter = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.02 * perimeter, True)
        
        # 筛选4顶点凸轮廓+对角线验证
        if len(approx) == 4 and cv2.isContourConvex(approx):
            pts = approx.reshape(4, 2)
            diag1 = np.linalg.norm(pts[0] - pts[2])
            diag2 = np.linalg.norm(pts[1] - pts[3])
            if abs(diag1 - diag2) / max(diag1, diag2) < 0.1:
                card_pts = order_card_vertices(pts)
                break
    
    return card_pts

# 实时帧处理示例（比如从摄像头读取）
cap = cv2.VideoCapture(0)
prev_pts = None
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    current_pts = detect_card(frame)
    if current_pts is not None:
        # 坐标平滑
        if prev_pts is not None:
            current_pts = 0.7 * current_pts + 0.3 * prev_pts
        prev_pts = current_pts
        
        # 绘制顶点（可选，用于可视化）
        for (x, y) in current_pts.astype(int):
            cv2.circle(frame, (x, y), 5, (255, 0, 0), -1)
        
        # 执行透视变换
        target_size = (300, 400)  # 卡片目标尺寸
        M = cv2.getPerspectiveTransform(current_pts, np.array([[0,0], [target_size[0],0], [target_size[0],target_size[1]], [0,target_size[1]]], dtype="float32"))
        warped = cv2.warpPerspective(frame, M, target_size)
        cv2.imshow("Warped Card", warped)
    
    cv2.imshow("Frame", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

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