Python OpenCV实现相机标定的完整代码示例

# ── 环境准备 ──────────────────────────────────────────────────────────────
import cv2
import numpy as np
# import matplotlib
import platform
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
# from matplotlib import font_manager
# import warnings
# warnings.filterwarnings('ignore')

# # 配置中文字体（使用系统内置的 noto cjk 字体）
# _font_path = '/usr/share/fonts/opentype/noto/notosanscjk-regular.ttc'
# try:
#     _zh_font = font_manager.fontproperties(fname=_font_path)
#     _zh_font_sm = font_manager.fontproperties(fname=_font_path, size=9)
#     _zh_font_md = font_manager.fontproperties(fname=_font_path, size=10)
#     _zh_font_lg = font_manager.fontproperties(fname=_font_path, size=13)
#     _zh_font_xl = font_manager.fontproperties(fname=_font_path, size=14)
#     print("✓ 中文字体加载成功")
# except exception:
#     _zh_font = _zh_font_sm = _zh_font_md = _zh_font_lg = _zh_font_xl = none
#     print("⚠ 未找到 noto cjk 字体，中文标注可能显示为方框")

if platform.system() == 'windows':
    plt.rcparams['font.sans-serif'] = ['simhei']
else:
    plt.rcparams['font.sans-serif'] = ['wenquanyi zen hei']
plt.rcparams['axes.unicode_minus'] = false

print(f"opencv 版本: {cv2.__version__}")
print(f"numpy  版本: {np.__version__}")

# ── 图1：四个坐标系关系示意图 ──────────────────────────────────────────────
fig, ax = plt.subplots(figsize=(13, 3))
ax.axis('off')
ax.set_xlim(0, 11)
ax.set_ylim(0, 2.8)

boxes = [
    ('世界坐标系\n$(x_w, y_w, z_w)$', 0.4),
    ('相机坐标系\n$(x_c, y_c, z_c)$', 3.0),
    ('图像物理坐标系\n$(x, y)$', 5.6),
    ('像素坐标系\n$(u, v)$', 8.2),
]
arrows = ['旋转 r\n平移 t', '透视投影\n焦距 f', '缩放\n平移']

for (label, x) in boxes:
    rect = mpatches.fancybboxpatch((x, 0.9), 2.2, 1.2,
                                    boxstyle='round,pad=0.1',
                                    linewidth=1.8, edgecolor='steelblue',
                                    facecolor='#ddeeff')
    ax.add_patch(rect)
    # ax.text(x + 1.1, 1.5, label, ha='center', va='center',
    #         fontproperties=_zh_font_sm)
    ax.text(x + 1.1, 1.5, label, ha='center', va='center')
for arrow_label, x_start in zip(arrows, [2.6, 5.2, 7.8]):
    ax.annotate('', xy=(x_start + 0.4, 1.5), xytext=(x_start, 1.5),
                arrowprops=dict(arrowstyle='->', color='tomato', lw=2))
    # ax.text(x_start + 0.2, 2.1, arrow_label, ha='center', va='bottom',
    #         fontproperties=_zh_font_sm, color='tomato')
    ax.text(x_start + 0.2, 2.1, arrow_label, ha='center', va='bottom', color='tomato')

# ax.set_title('相机成像的四个坐标系及其转换关系', fontproperties=_zh_font_xl)
ax.set_title('相机成像的四个坐标系及其转换关系')
plt.tight_layout()
plt.show()

# ── 图2：针孔相机成像原理示意图 ────────────────────────────────────────────
fig, ax = plt.subplots(figsize=(11, 5))
ax.set_xlim(0, 10)
ax.set_ylim(-3.2, 3.2)
ax.set_aspect('equal')
ax.axis('off')

# 光轴
ax.annotate('', xy=(9.5, 0), xytext=(0.5, 0),
            arrowprops=dict(arrowstyle='->', color='gray', lw=1.5))
# ax.text(9.55, 0.15, '光轴 z', fontsize=10, color='gray', fontproperties=_zh_font_md)
ax.text(9.55, 0.15, '光轴 z', fontsize=10, color='gray')

# 物体
ax.plot([2, 2], [0, 2.2], 'g-', lw=4)
ax.plot([2], [2.2], 'g^', markersize=14)
# ax.text(1.4, -0.45, '物体 p', fontsize=10, ha='center', fontproperties=_zh_font_md)
ax.text(1.4, -0.45, '物体 p', fontsize=10, ha='center')

# 光心
ax.plot(5, 0, 'ko', markersize=12)
# ax.text(5, -0.5, '光心 o', fontsize=10, ha='center', fontproperties=_zh_font_md)
ax.text(5, -0.5, '光心 o', fontsize=10, ha='center')

# 成像平面
ax.plot([7.5, 7.5], [-2.2, 2.2], 'b-', lw=3)
# ax.text(7.5, -2.7, '成像平面', fontsize=10, ha='center', fontproperties=_zh_font_md)
ax.text(7.5, -2.7, '成像平面', fontsize=10, ha='center')

# 投影线
ax.plot([2, 7.5], [2.2, -1.65], 'r--', lw=1.5, alpha=0.7)
ax.plot([2, 7.5], [0, 0], 'r--', lw=1.5, alpha=0.7)

# 像点
ax.plot([7.5], [-1.65], 'r^', markersize=12)
# ax.text(7.85, -1.65, "像点 p'", fontsize=10, fontproperties=_zh_font_md)
ax.text(7.85, -1.65, "像点 p'", fontsize=10)

# 焦距标注
ax.annotate('', xy=(7.5, -3.0), xytext=(5, -3.0),
            arrowprops=dict(arrowstyle='<->', color='purple', lw=1.5))
# ax.text(6.25, -3.2, '焦距 f', fontsize=10, ha='center', color='purple', fontproperties=_zh_font_md)
ax.text(6.25, -3.2, '焦距 f', fontsize=10, ha='center', color='purple')

# 物距标注
ax.annotate('', xy=(5, 3.0), xytext=(2, 3.0),
            arrowprops=dict(arrowstyle='<->', color='darkgreen', lw=1.5))
# ax.text(3.5, 3.15, '物距 z', fontsize=10, ha='center', color='darkgreen', fontproperties=_zh_font_md)
ax.text(3.5, 3.15, '物距 z', fontsize=10, ha='center', color='darkgreen')

# ax.set_title('针孔相机成像原理示意图', fontproperties=_zh_font_xl, pad=15)
ax.set_title('针孔相机成像原理示意图', pad=15)
plt.tight_layout()
plt.show()

# ── 图3：径向畸变类型对比 ──────────────────────────────────────────────────
fig, axes = plt.subplots(1, 3, figsize=(13, 4.5))

def draw_distorted_grid(ax, distort_fn, title):
    ax.set_xlim(-1.5, 1.5)
    ax.set_ylim(-1.5, 1.5)
    ax.set_aspect('equal')
    ax.axis('off')
    # ax.set_title(title, fontproperties=_zh_font_lg)
    ax.set_title(title)
    for v in np.linspace(-1.2, 1.2, 7):
        pts = [distort_fn(u, v) for u in np.linspace(-1.2, 1.2, 120)]
        ax.plot([p[0] for p in pts], [p[1] for p in pts], 'steelblue', lw=1.2)
    for u in np.linspace(-1.2, 1.2, 7):
        pts = [distort_fn(u, v) for v in np.linspace(-1.2, 1.2, 120)]
        ax.plot([p[0] for p in pts], [p[1] for p in pts], 'steelblue', lw=1.2)

draw_distorted_grid(axes[0], lambda x, y: (x, y), '无畸变（理想模型）')
draw_distorted_grid(axes[1],
    lambda x, y: (x*(1 - 0.3*(x**2+y**2)), y*(1 - 0.3*(x**2+y**2))),
    '桶形畸变\n($k_1 < 0$，图像向内收缩)')
draw_distorted_grid(axes[2],
    lambda x, y: (x*(1 + 0.3*(x**2+y**2)), y*(1 + 0.3*(x**2+y**2))),
    '枕形畸变\n($k_1 > 0$，图像向外扩张)')

# plt.suptitle('径向畸变类型示意图', fontproperties=_zh_font_xl, y=1.02)
plt.suptitle('径向畸变类型示意图', y=1.02)
plt.tight_layout()
plt.show()

# ── 图4：张正友标定法完整流程图 ────────────────────────────────────────────
fig, ax = plt.subplots(figsize=(11, 8))
ax.axis('off')
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)

steps = [
    ('① 打印棋盘格标定板，从多角度拍摄若干张图像（建议 15~20 张）', '#4472c4', '#dce6f1'),
    ('② 调用 findchessboardcorners 提取每张图像的内角点像素坐标', '#ed7d31', '#fce4d6'),
    ('③ 调用 cornersubpix 将角点坐标精化至亚像素级别', '#70ad47', '#e2efda'),
    ('④ 调用 calibratecamera 求解内参矩阵 k 和畸变系数 d', '#ff0000', '#ffd7d7'),
    ('⑤ 利用 undistort / initundistortrectifymap 对图像进行去畸变', '#7030a0', '#ede7f6'),
    ('⑥ 评估重投影误差，必要时增补图像并重新标定', '#c00000', '#f4cccc'),
]

y_positions = [9.0, 7.4, 5.8, 4.2, 2.6, 1.0]

for (text, edge_color, face_color), y in zip(steps, y_positions):
    rect = mpatches.fancybboxpatch((0.4, y - 0.55), 9.2, 1.1,
                                    boxstyle='round,pad=0.1',
                                    linewidth=2, edgecolor=edge_color,
                                    facecolor=face_color)
    ax.add_patch(rect)
    # ax.text(5, y, text, ha='center', va='center',
    #         fontproperties=_zh_font_md, color='#1a1a1a')
    ax.text(5, y, text, ha='center', va='center', color='#1a1a1a')

for y_cur, y_next in zip(y_positions[:-1], y_positions[1:]):
    ax.annotate('', xy=(5, y_next + 0.55), xytext=(5, y_cur - 0.55),
                arrowprops=dict(arrowstyle='->', color='#444444', lw=2))

# ax.set_title('张正友相机标定法完整流程（opencv 实现）',
#              fontproperties=_zh_font_xl, pad=12)
ax.set_title('张正友相机标定法完整流程（opencv 实现）', pad=12)
plt.tight_layout()
plt.show()

# ── 步骤 1：生成模拟棋盘格图像（实际应用中应替换为真实拍摄的照片）─────────

checkerboard = (6, 9)   # 棋盘格内角点数量 (行数, 列数)
square_size  = 0.025    # 每个方格的物理边长（单位：米）

def generate_checkerboard(rows, cols, step=56, margin=60,
                           img_h=480, img_w=640):
    """生成标准棋盘格灰度图像。"""
    img = np.ones((img_h, img_w), dtype=np.uint8) * 255
    for i in range(cols + 1):
        for j in range(rows + 1):
            if (i + j) % 2 == 0:
                x1 = margin + i * step
                y1 = margin + j * step
                x2 = min(x1 + step, img_w - 1)
                y2 = min(y1 + step, img_h - 1)
                cv2.rectangle(img, (x1, y1), (x2, y2), 0, -1)
    return img

# 生成一张基准棋盘格图像
base_board = generate_checkerboard(*checkerboard)

# 通过仿射变换模拟多角度拍摄，生成 12 张不同视角的图像
def make_perspective_views(base, n=12):
    h, w = base.shape
    views = []
    np.random.seed(42)
    for _ in range(n):
        # 随机仿射变换（模拟轻微旋转和缩放）
        angle = np.random.uniform(-12, 12)
        scale = np.random.uniform(0.85, 1.0)
        m = cv2.getrotationmatrix2d((w // 2, h // 2), angle, scale)
        m[0, 2] += np.random.uniform(-20, 20)
        m[1, 2] += np.random.uniform(-15, 15)
        warped = cv2.warpaffine(base, m, (w, h),
                                flags=cv2.inter_linear,
                                bordermode=cv2.border_constant,
                                bordervalue=255)
        views.append(warped)
    return views

images = make_perspective_views(base_board, n=12)
print(f"共生成 {len(images)} 张模拟标定图像，尺寸：{images[0].shape}")

# ── 步骤 2：角点检测与亚像素精化 ──────────────────────────────────────────

# 停止准则：最大迭代次数 30 次，或精度达到 0.001 像素
criteria = (cv2.term_criteria_eps + cv2.term_criteria_max_iter, 30, 0.001)

# 准备世界坐标系中的角点坐标（z=0 平面）
objp = np.zeros((checkerboard[0] * checkerboard[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:checkerboard[0],
                        0:checkerboard[1]].t.reshape(-1, 2) * square_size

objpoints = []  # 3d 世界坐标点列表
imgpoints = []  # 2d 图像像素坐标点列表
valid_images = []

for idx, gray in enumerate(images):
    ret, corners = cv2.findchessboardcorners(gray, checkerboard, none)
    if ret:
        # cornersubpix：将角点精化到亚像素精度
        corners_refined = cv2.cornersubpix(
            gray, corners, (11, 11), (-1, -1), criteria)
        objpoints.append(objp)
        imgpoints.append(corners_refined)
        valid_images.append(gray)

print(f"成功检测到角点的图像数量：{len(valid_images)} / {len(images)}")

# 可视化第一张有效图像的角点检测结果
img_vis = cv2.cvtcolor(valid_images[0], cv2.color_gray2bgr)
cv2.drawchessboardcorners(img_vis, checkerboard, imgpoints[0], true)

fig, axes = plt.subplots(1, 2, figsize=(13, 5))
axes[0].imshow(valid_images[0], cmap='gray')
# axes[0].set_title('原始棋盘格图像', fontproperties=_zh_font_lg)
axes[0].set_title('原始棋盘格图像')
axes[0].axis('off')
axes[1].imshow(cv2.cvtcolor(img_vis, cv2.color_bgr2rgb))
# axes[1].set_title('角点检测结果（findchessboardcorners + cornersubpix）',
#                    fontproperties=_zh_font_lg)
axes[1].set_title('角点检测结果（findchessboardcorners + cornersubpix）')
axes[1].axis('off')
# plt.suptitle('张正友标定法 — 棋盘格角点检测与精化', fontproperties=_zh_font_xl)
plt.suptitle('张正友标定法 — 棋盘格角点检测与精化')
plt.tight_layout()
plt.show()

# ── 步骤 3：执行相机标定 ───────────────────────────────────────────────────

img_size = (valid_images[0].shape[1], valid_images[0].shape[0])  # (width, height)

# cv2.calibratecamera 返回：
#   ret    — 平均重投影误差（越小越好，通常要求 < 1.0 像素）
#   mtx    — 3×3 相机内参矩阵 k
#   dist   — 畸变系数向量 [k1, k2, p1, p2, k3]
#   rvecs  — 每张图像的旋转向量列表
#   tvecs  — 每张图像的平移向量列表
ret, mtx, dist, rvecs, tvecs = cv2.calibratecamera(
    objpoints, imgpoints, img_size, none, none)

print("=" * 55)
print("  相机标定结果")
print("=" * 55)
print(f"\n平均重投影误差 (rms): {ret:.4f} 像素")
print("\n内参矩阵 k:")
print(f"  fx = {mtx[0,0]:.2f} px,  fy = {mtx[1,1]:.2f} px")
print(f"  cx = {mtx[0,2]:.2f} px,  cy = {mtx[1,2]:.2f} px")
print("\n  k =\n", np.round(mtx, 2))
print("\n畸变系数 [k1, k2, p1, p2, k3]:")
print("  ", np.round(dist.ravel(), 6))
print("=" * 55)

# ── 步骤 4：去畸变处理 ────────────────────────────────────────────────────
# 模拟一张带有桶形畸变的网格图像，演示去畸变效果

h_g, w_g = 400, 400
img_grid = np.ones((h_g, w_g, 3), dtype=np.uint8) * 255
for i in range(0, h_g, 40):
    cv2.line(img_grid, (0, i), (w_g, i), (160, 160, 160), 1)
for j in range(0, w_g, 40):
    cv2.line(img_grid, (j, 0), (j, h_g), (160, 160, 160), 1)
cv2.rectangle(img_grid, (0, 0), (w_g-1, h_g-1), (0, 0, 0), 2)

# 使用模拟的相机参数和畸变系数引入桶形畸变
k_sim = np.array([[350., 0., 200.], [0., 350., 200.], [0., 0., 1.]])
d_sim = np.array([-0.4, 0.15, 0., 0., 0.])
map1, map2 = cv2.initundistortrectifymap(
    k_sim, d_sim, none, k_sim, (w_g, h_g), cv2.cv_32fc1)
img_distorted = cv2.remap(img_grid, map1, map2, cv2.inter_linear)

# 使用 cv2.undistort 进行去畸变
img_undistorted = cv2.undistort(img_distorted, k_sim, d_sim)

fig, axes = plt.subplots(1, 3, figsize=(14, 5))
axes[0].imshow(img_grid)
# axes[0].set_title('原始网格图像（理想无畸变）', fontproperties=_zh_font_lg)
axes[0].set_title('原始网格图像（理想无畸变）')
axes[0].axis('off')
axes[1].imshow(img_distorted)
# axes[1].set_title('引入桶形畸变后的图像', fontproperties=_zh_font_lg)
axes[1].set_title('引入桶形畸变后的图像')
axes[1].axis('off')
axes[2].imshow(img_undistorted)
# axes[2].set_title('cv2.undistort 去畸变结果', fontproperties=_zh_font_lg)
axes[2].set_title('cv2.undistort 去畸变结果')
axes[2].axis('off')
# plt.suptitle('相机标定 — 去畸变效果对比', fontproperties=_zh_font_xl)
plt.suptitle('相机标定 — 去畸变效果对比')
plt.tight_layout()
plt.show()

# ── 步骤 5：重投影误差评估 ────────────────────────────────────────────────
# 重投影误差是衡量标定质量的核心指标：
# 将已知3d点用标定结果重新投影到图像，计算与实际检测点的距离误差

errors = []
for i in range(len(objpoints)):
    # 将3d点重新投影到图像平面
    projected, _ = cv2.projectpoints(
        objpoints[i], rvecs[i], tvecs[i], mtx, dist)
    # 计算与实际检测角点的欧氏距离
    actual = imgpoints[i].reshape(-1, 2).astype(np.float32)
    proj   = projected.reshape(-1, 2).astype(np.float32)
    err = np.sqrt(np.mean(np.sum((actual - proj)**2, axis=1)))
    errors.append(err)

fig, ax = plt.subplots(figsize=(9, 4))
bars = ax.bar(range(1, len(errors)+1), errors,
              color='steelblue', edgecolor='white', linewidth=0.8)
ax.axhline(np.mean(errors), color='tomato', lw=2, ls='--',
           label=f'平均误差 = {np.mean(errors):.4f} px')
# ax.set_xlabel('图像编号', fontproperties=_zh_font_md)
ax.set_xlabel('图像编号')
# ax.set_ylabel('重投影误差（像素）', fontproperties=_zh_font_md)
ax.set_ylabel('重投影误差（像素）')
# ax.set_title('各图像的重投影误差分布', fontproperties=_zh_font_xl)
ax.set_title('各图像的重投影误差分布')
# ax.legend(prop=_zh_font_md)
ax.legend()
ax.set_xticks(range(1, len(errors)+1))
plt.tight_layout()
plt.show()

print(f"平均重投影误差：{np.mean(errors):.4f} 像素")
print("（通常认为误差 < 1.0 像素为合格，< 0.5 像素为优秀）")

# ── 比例因子法：生成演示场景 ──────────────────────────────────────────────
# 场景描述：
#   左侧：参考物（已知宽度 = 2.0 cm，像素宽度 = 100 px）
#   右侧：待测物（宽度未知，像素宽度约 230 px）

known_width_cm = 2.0  # 参考物的实际宽度（厘米）

# 构建演示图像
scene = np.ones((420, 720, 3), dtype=np.uint8) * 245

# 参考物（橙色边框）：像素宽度 = 180-80 = 100 px
cv2.rectangle(scene, (80, 150), (180, 260), (30, 30, 30), -1)
cv2.rectangle(scene, (80, 150), (180, 260), (0, 120, 220), 3)
cv2.puttext(scene, 'reference object', (60, 140),
            cv2.font_hershey_simplex, 0.55, (0, 120, 220), 1)
# 宽度标注
cv2.arrowedline(scene, (80, 285), (180, 285), (0, 120, 220), 2, tiplength=0.15)
cv2.arrowedline(scene, (180, 285), (80, 285), (0, 120, 220), 2, tiplength=0.15)
cv2.puttext(scene, '100 px = 2.0 cm', (55, 308),
            cv2.font_hershey_simplex, 0.55, (0, 120, 220), 1)

# 待测物（绿色边框）：像素宽度 = 560-330 = 230 px
cv2.rectangle(scene, (330, 110), (560, 300), (30, 30, 30), -1)
cv2.rectangle(scene, (330, 110), (560, 300), (0, 170, 80), 3)
cv2.puttext(scene, 'unknown object', (330, 100),
            cv2.font_hershey_simplex, 0.55, (0, 170, 80), 1)
# 宽度标注
cv2.arrowedline(scene, (330, 325), (560, 325), (0, 170, 80), 2, tiplength=0.08)
cv2.arrowedline(scene, (560, 325), (330, 325), (0, 170, 80), 2, tiplength=0.08)
cv2.puttext(scene, '230 px = ? cm', (360, 348),
            cv2.font_hershey_simplex, 0.55, (0, 170, 80), 1)

# 公式说明
cv2.puttext(scene, 'scale factor = 100 px / 2.0 cm = 50 px/cm',
            (40, 380), cv2.font_hershey_simplex, 0.6, (140, 0, 160), 2)
cv2.puttext(scene, 'unknown width = 230 px / 50 px/cm = 4.6 cm',
            (40, 410), cv2.font_hershey_simplex, 0.6, (140, 0, 160), 2)

fig, ax = plt.subplots(figsize=(11, 6))
ax.imshow(cv2.cvtcolor(scene, cv2.color_bgr2rgb))
# ax.set_title('比例因子计算方法 — 尺寸测量示意图', fontproperties=_zh_font_xl)
ax.set_title('比例因子计算方法 — 尺寸测量示意图')
ax.axis('off')
plt.tight_layout()
plt.show()

# ── 比例因子法：完整代码实现 ──────────────────────────────────────────────
# 本示例演示如何利用轮廓检测自动计算比例因子并测量物体尺寸

def order_points(pts):
    """将矩形的四个顶点按 [左上, 右上, 右下, 左下] 排序。"""
    rect = np.zeros((4, 2), dtype='float32')
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]   # 左上
    rect[2] = pts[np.argmax(s)]   # 右下
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)]  # 右上
    rect[3] = pts[np.argmax(diff)]  # 左下
    return rect

def midpoint(pta, ptb):
    return ((pta[0] + ptb[0]) * 0.5, (pta[1] + ptb[1]) * 0.5)

# 1. 图像预处理
gray_scene = cv2.cvtcolor(scene, cv2.color_bgr2gray)
blurred = cv2.gaussianblur(gray_scene, (7, 7), 0)
edged = cv2.canny(blurred, 30, 100)
edged = cv2.dilate(edged, none, iterations=1)
edged = cv2.erode(edged, none, iterations=1)

# 2. 轮廓检测
cnts, _ = cv2.findcontours(
    edged.copy(), cv2.retr_external, cv2.chain_approx_simple)

# 过滤面积过小的噪声轮廓，并按 x 坐标从左到右排序
cnts = [c for c in cnts if cv2.contourarea(c) > 500]
cnts = sorted(cnts, key=lambda c: cv2.boundingrect(c)[0])

pixels_per_cm = none
result_img = scene.copy()
measurements = []

for c in cnts:
    # 计算最小外接矩形
    box = cv2.minarearect(c)
    box_pts = cv2.boxpoints(box)
    box_pts = np.intp(box_pts)
    ordered = order_points(box_pts.astype('float32'))

    tl, tr, br, bl = ordered
    # 计算矩形的宽和高（像素）
    width_px  = np.linalg.norm(tr - tl)
    height_px = np.linalg.norm(bl - tl)

    # 第一个（最左侧）轮廓作为参考物，初始化比例因子
    if pixels_per_cm is none:
        pixels_per_cm = width_px / known_width_cm
        label = f'ref: {known_width_cm:.1f}cm'
        color = (0, 120, 220)
    else:
        w_cm = width_px  / pixels_per_cm
        h_cm = height_px / pixels_per_cm
        label = f'{w_cm:.1f} x {h_cm:.1f} cm'
        color = (0, 170, 80)
        measurements.append((w_cm, h_cm))

    cv2.drawcontours(result_img, [box_pts], -1, color, 2)
    cx, cy = int(np.mean(ordered[:, 0])), int(np.mean(ordered[:, 1]))
    cv2.puttext(result_img, label, (cx - 50, cy),
                cv2.font_hershey_simplex, 0.65, color, 2)

print(f"计算得到的比例因子：{pixels_per_cm:.2f} px/cm")
for i, (w, h) in enumerate(measurements):
    print(f"待测物 {i+1} 的实际尺寸：宽 = {w:.2f} cm，高 = {h:.2f} cm")

fig, ax = plt.subplots(figsize=(11, 6))
ax.imshow(cv2.cvtcolor(result_img, cv2.color_bgr2rgb))
# ax.set_title('比例因子法 — 自动轮廓检测与尺寸测量结果', fontproperties=_zh_font_xl)
ax.set_title('比例因子法 — 自动轮廓检测与尺寸测量结果')
ax.axis('off')
plt.tight_layout()
plt.show()

# ── 图：两种方法对比可视化 ────────────────────────────────────────────────
fig, ax = plt.subplots(figsize=(13, 5.5))
ax.axis('off')

headers = ['对比维度', '张正友标定法', '比例因子计算方法']
rows = [
    ['标定物', '二维棋盘格标定板（已知格点尺寸）', '任意已知尺寸的参考物体'],
    ['输出结果', '内参矩阵 k、外参 [r|t]、畸变系数 d', '像素/物理单位的换算比例'],
    ['精度', '高（可达亚像素级别）', '中等（受透视和畸变影响）'],
    ['适用场景', '三维重建、机器人定位、双目视觉', '固定场景下的平面尺寸估算'],
    ['操作复杂度', '较高（需多角度拍摄 15~20 张）', '低（只需一张含参考物的图像）'],
    ['关键 api', 'calibratecamera, undistort', 'findcontours, minarearect'],
]

col_widths = [0.22, 0.39, 0.39]
col_starts = [0.0, 0.22, 0.61]
row_height = 0.13
header_y = 0.88

# 绘制表头
for j, (h, x, w) in enumerate(zip(headers, col_starts, col_widths)):
    rect = mpatches.fancybboxpatch((x + 0.005, header_y), w - 0.01, row_height,
                                    transform=ax.transaxes,
                                    boxstyle='square,pad=0', clip_on=false,
                                    linewidth=0, facecolor='#2e5fa3')
    ax.add_patch(rect)
    # ax.text(x + w/2, header_y + row_height/2, h,
    #         transform=ax.transaxes, ha='center', va='center',
    #         fontproperties=_zh_font_md, color='white', fontweight='bold')
    ax.text(x + w/2, header_y + row_height/2, h,
            transform=ax.transaxes, ha='center', va='center',
            color='white', fontweight='bold')

# 绘制数据行
for i, row in enumerate(rows):
    y = header_y - (i + 1) * (row_height + 0.005)
    bg = '#f0f4ff' if i % 2 == 0 else '#ffffff'
    for j, (cell, x, w) in enumerate(zip(row, col_starts, col_widths)):
        rect = mpatches.fancybboxpatch((x + 0.005, y), w - 0.01, row_height,
                                        transform=ax.transaxes,
                                        boxstyle='square,pad=0', clip_on=false,
                                        linewidth=0.5, edgecolor='#cccccc',
                                        facecolor=bg if j > 0 else '#e8f0fe')
        ax.add_patch(rect)
        # ax.text(x + w/2, y + row_height/2, cell,
        #         transform=ax.transaxes, ha='center', va='center',
        #         fontproperties=_zh_font_sm, color='#222222')
        ax.text(x + w/2, y + row_height/2, cell,
                transform=ax.transaxes, ha='center', va='center',
                color='#222222')

# ax.set_title('张正友标定法 vs. 比例因子计算方法 — 综合对比',
#              fontproperties=_zh_font_xl, pad=15)
ax.set_title('张正友标定法 vs. 比例因子计算方法 — 综合对比', pad=15)
plt.tight_layout()
plt.show()