相机标定知识梳理 (Camera Calibration Guide)

import cv2
import numpy as np
import glob

# === 1. 准备标定板参数 ===
# 棋盘格内角点数量 (列, 行)
pattern_size = (9, 6)
# 每个方格的实际尺寸 (单位：米)
square_size = 0.025

# === 2. 采集图像并检测角点 ===
object_points = []  # 3D 世界坐标 (Z=0)
image_points = []   # 2D 像素坐标

# 生成标定板角点的世界坐标 (假设标定板在 Z=0 平面)
objp = np.zeros((pattern_size[0]*pattern_size[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
objp *= square_size

# 遍历所有标定图像
for fname in glob.glob('calib_images/*.png'):
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 检测角点 (亚像素精度)
    ret, corners = cv2.findChessboardCorners(gray, pattern_size, 
                                             cv2.CALIB_CB_ADAPTIVE_THRESH)
    if ret:
        # 亚像素优化
        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 
                    30, 0.001)
        corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        
        object_points.append(objp)
        image_points.append(corners)
        
        # 可视化检测效果 (可选)
        cv2.drawChessboardCorners(img, pattern_size, corners, ret)
        cv2.imshow('Detected', img)
        cv2.waitKey(500)

# === 3. 执行标定 ===
ret, K, dist, rvecs, tvecs = cv2.calibrateCamera(
    object_points,      # 3D 点集
    image_points,       # 2D 点集
    gray.shape[::-1],   # 图像尺寸 (width, height)
    None, None,         # 内参/畸变初值 (None=自动估计)
    flags=cv2.CALIB_FIX_K3 + cv2.CALIB_ZERO_TANGENT_DIST  # 约束条件
)

print(f"重投影误差 (RMS): {ret:.4f} pixels")
print(f"内参矩阵 K:\n{K}")
print(f"畸变系数: {dist.ravel()}")

# === 4. 畸变矫正演示 ===
def undistort_and_show(img, K, dist):
    # 方法 1: 直接矫正 (简单)
    undist = cv2.undistort(img, K, dist)
    
    # 方法 2: 映射表矫正 (高效，适合视频流)
    map1, map2 = cv2.initUndistortRectifyMap(K, dist, None, K, 
                                             img.shape[1::-1], cv2.CV_16SC2)
    undist_fast = cv2.remap(img, map1, map2, interpolation=cv2.INTER_LINEAR)
    
    # 并排显示对比
    result = np.hstack([img, undist])
    cv2.imshow('Original vs Undistorted', result)
    cv2.waitKey(0)

# 测试一张图
test_img = cv2.imread('calib_images/test.png')
undistort_and_show(test_img, K, dist)

# 🔍 评估 1: 重投影误差分布
errors = []
for i in range(len(object_points)):
    img_points_proj, _ = cv2.projectPoints(
        object_points[i], rvecs[i], tvecs[i], K, dist)
    error = cv2.norm(image_points[i], img_points_proj, cv2.NORM_L2) / len(img_points_proj)
    errors.append(error)

print(f"平均误差: {np.mean(errors):.3f}px, 最大误差: {np.max(errors):.3f}px")

# 🔍 评估 2: 外参可视化 (以相机为中心)
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')

# 绘制相机坐标系
ax.quiver(0, 0, 0, 1, 0, 0, color='r', length=0.1, label='X')
ax.quiver(0, 0, 0, 0, 1, 0, color='g', length=0.1, label='Y')
ax.quiver(0, 0, 0, 0, 0, 1, color='b', length=0.1, label='Z')

# 绘制各次标定的标定板位置
for R_vec, t in zip(rvecs, tvecs):
    R, _ = cv2.Rodrigues(R_vec)  # 旋转向量→旋转矩阵
    # 标定板四个角点 (世界坐标)
    corners_3d = np.array([
        [0, 0, 0],
        [pattern_size[0]*square_size, 0, 0],
        [pattern_size[0]*square_size, pattern_size[1]*square_size, 0],
        [0, pattern_size[1]*square_size, 0]
    ]).T
    # 变换到相机坐标系
    corners_cam = R @ corners_3d + t
    ax.plot(corners_cam[0], corners_cam[1], corners_cam[2], 'k-')

ax.set_xlabel('X'); ax.set_ylabel('Y'); ax.set_zlabel('Z')
ax.set_title('Calibration Poses (Camera-Centered)')
ax.legend(); plt.tight_layout(); plt.show()

# === 1. 分别标定左右相机 (获取 K1, dist1, K2, dist2) ===
# ... (调用单目标定代码) ...

# === 2. 双目标定：求解相对位姿 [R, T] ===
flags = cv2.CALIB_FIX_INTRINSIC  # 固定已标定的内参
ret, K1, dist1, K2, dist2, R, T, E, F = cv2.stereoCalibrate(
    object_points, image_points1, image_points2,
    K1, dist1, K2, dist2, gray.shape[::-1],
    flags=flags, criteria=(cv2.TERM_CRITERIA_EPS+cv2.TERM_CRITERIA_MAX_ITER, 100, 1e-5)
)

# === 3. 立体校正：生成行对齐的映射表 ===
# 输出：校正旋转矩阵 R1, R2 + 投影矩阵 P1, P2 + 重投影矩阵 Q
R1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(
    K1, dist1, K2, dist2, gray.shape[::-1], R, T,
    alpha=0,  # 0=裁剪黑边，1=保留全部像素
    newImageSize=(width, height)
)

# === 4. 生成畸变矫正 + 立体校正的映射表 ===
map1_L, map2_L = cv2.initUndistortRectifyMap(K1, dist1, R1, P1[:3,:3], 
                                             (width, height), cv2.CV_16SC2)
map1_R, map2_R = cv2.initUndistortRectifyMap(K2, dist2, R2, P2[:3,:3], 
                                             (width, height), cv2.CV_16SC2)

# === 5. 实时校正函数 (用于视频流) ===
def rectify_pair(img_L, img_R):
    undist_L = cv2.remap(img_L, map1_L, map2_L, cv2.INTER_LINEAR)
    undist_R = cv2.remap(img_R, map1_R, map2_R, cv2.INTER_LINEAR)
    return undist_L, undist_R

# === 6. 深度计算 (使用重投影矩阵 Q) ===
# 先计算视差图 (见第 7 节)，然后：
disparity = stereo_match(rect_L, rect_R)  # 单位：像素
depth_map = cv2.reprojectImageTo3D(disparity, Q)  # 输出：XYZ 三维坐标

# === BM (Block Matching) - 快速但精度一般 ===
bm = cv2.StereoBM_create(
    numDisparities=16*5,   # 视差范围 (需为 16 倍数)
    blockSize=15           # SAD 窗口大小 (奇数)
)
bm.setPreFilterCap(31)
bm.setTextureThreshold(10)
bm.setUniquenessRatio(10)  # 唯一性阈值 (%)
bm.setSpeckleWindowSize(100)  # 斑点过滤
bm.setSpeckleRange(32)

# === SGBM (Semi-Global BM) - 精度高，推荐默认使用 ===
sgbm = cv2.StereoSGBM_create(
    minDisparity=0,
    numDisparities=16*5,   # 同上
    blockSize=5,           # 通常 3~7
    P1=8*3*5**2,           # 小视差变化惩罚
    P2=32*3*5**2,          # 大视差变化惩罚
    disp12MaxDiff=1,       # 左右一致性检查阈值
    preFilterCap=63,
    uniquenessRatio=10,
    speckleWindowSize=100,
    speckleRange=32,
    mode=cv2.STEREO_SGBM_MODE_SGBM_3WAY  # 3 路径/5 路径/全路径
)

# === 计算视差图 ===
disparity = sgbm.compute(rect_L, rect_R).astype(np.float32) / 16.0  # SGBM 输出×16

# === 可视化 (注意：视差图需归一化显示) ===
disp_vis = cv2.normalize(disparity, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
disp_vis = cv2.applyColorMap(disp_vis, cv2.COLORMAP_JET)
cv2.imshow('Disparity', disp_vis)

import cv2
import numpy as np

# === 1. 准备参数 (注意：用 fisheye 模块！) ===
pattern_size = (9, 6)
square_size = 0.025
flags = cv2.fisheye.CALIB_RECOMPUTE_EXTRINSIC + \
        cv2.fisheye.CALIB_CHECK_COND + \
        cv2.fisheye.CALIB_FIX_SKEW

# === 2. 角点检测 (同单目，但用 fisheye 接口) ===
object_points = []  # 3D 点
image_points = []   # 2D 点
# ... (检测代码同前，略) ...

# === 3. 鱼眼标定 ===
K = np.zeros((3, 3))
D = np.zeros((4, 1))  # [k1, k2, k3, k4]
rvecs = []
tvecs = []

rms, _, _, _, _ = cv2.fisheye.calibrate(
    object_points, image_points, gray.shape[::-1],
    K, D, rvecs, tvecs, flags,
    (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 100, 1e-6)
)

print(f"鱼眼标定误差: {rms:.4f}px")
print(f"内参:\n{K}")
print(f"KB 畸变系数: {D.ravel()}")

# === 4. 鱼眼畸变矫正 (两种模式) ===
def fisheye_undistort(img, K, D, balance=0.6, fov_scale=1.0):
    """
    balance: 0~1, 0=裁剪黑边最多但视场最大, 1=保留全部像素但视场小
    fov_scale: >1 放大视场 (可能插值), <1 缩小视场
    """
    # 计算新内参 (可选调整视场)
    new_K = cv2.fisheye.estimateNewCameraMatrixForUndistortRectify(
        K, D, img.shape[1::-1], np.eye(3), 
        balance=balance, fov_scale=fov_scale)
    
    # 生成映射表
    map1, map2 = cv2.fisheye.initUndistortRectifyMap(
        K, D, np.eye(3), new_K, img.shape[1::-1], cv2.CV_16SC2)
    
    # 执行矫正
    undist = cv2.remap(img, map1, map2, interpolation=cv2.INTER_LINEAR, 
                       borderMode=cv2.BORDER_REPLICATE)
    return undist, new_K

# 测试矫正效果
test_img = cv2.imread('fisheye_test.jpg')
undist, new_K = fisheye_undistort(test_img, K, D, balance=0.8)
cv2.imwrite('undistorted.jpg', undist)

- [ ] 标定板覆盖图像四角 + 中心 (避免中心密集)
- [ ] 采集 10~20 张，姿态变化 > 30° (旋转+平移)
- [ ] 标定板与相机距离：0.5m ~ 2m (覆盖工作距离)
- [ ] 光照均匀，避免反光/阴影/运动模糊
- [ ] 固定焦距！禁用自动对焦 (标定后勿变焦)
- [ ] 用 PNG 无损格式保存图像 (避免 JPEG 压缩伪影)