摄像头是机器人、监控、太空探索、社交媒体、工业自动化甚至娱乐业等多个领域不可或缺的一部分。 对于许多应用，必须了解相机的参数才能有效地将其用作视觉传感器。

在这篇文章中，您将了解相机校准所涉及的步骤及其意义。 我们还共享 C++ 和 Python 代码以及棋盘图案的示例图像。

1.什么是相机标定

估计相机参数的过程称为相机标定。

这意味着我们拥有确定现实世界中的 3D 点与其在该校准相机捕获的图像中对应的 2D 投影（像素）之间的准确关系所需的有关相机的所有信息（参数或系数）。

通常这意味着恢复两种参数：

• 相机/镜头系统的内部参数。例如。镜头的焦距、光学中心和径向畸变系数。
• 外部参数：这是指相机相对于某个世界坐标系的方向（旋转和平移）。

在下面的图像中，使用几何标定估计出的镜头参数来消除图像的畸变。

2.使用OpenCV进行摄像机标定

要找到 3D 点在图像平面上的投影，我们首先需要使用外部参数（旋转和平移）将点从世界坐标系转换到相机坐标系。

接下来，使用相机的内部参数，我们将点投影到图像平面上。

将世界坐标中的 3D 点 (X_w, Y_w, Z_w)与其在图像坐标中的投影 (u, v)相关联的方程如下所示：

其中，P是一个 3×4 投影矩阵，由两部分组成 - 包含内在参数的内在矩阵 K 和由 3×3 旋转矩阵R和 3×1 平移向量t组合而成的外在矩阵 [R|t]。

如前所述，内在矩阵 K 是上三角形矩阵。

$f_x,f_y$是 x 和 y 焦距（是的，它们通常是相同的）。
$c_x,c_y$是图像平面中光学中心的 x 和 y 坐标。使用图像的中心通常是一个足够好的近似值。
$\gamma$是轴之间的偏斜。通常为 0。

3.相机标定的目标

相机标定的目标是使用一组已知的 3D 点$(X_w,Y_w,Z_w)$及其对应的图像坐标$(u,v)$找到 3×3 矩阵$K$、3×3 旋转矩阵$R$和 3×1 平移向量$t$。当我们得到内在和外在参数的值时，相机就被称为是经过标定的。

综上所述，一个相机标定算法有以下输入和输出

• 输入：一组图像，其中包含已知 2D 图像坐标和 3D 世界坐标的点。
• 输出：3×3 相机内在矩阵，每个图像的旋转和平移。

注意：在 OpenCV 中，相机内在矩阵没有 skew 参数。所以矩阵的形式是：

4.不同类型的相机标定方法

• 标定板：当我们完全控制成像过程时，执行标定的最佳方法是从不同的视点捕获物体或已知尺寸图案的多张图像。我们将在这篇文章中学习的基于棋盘格的方法属于这一类。我们也可以使用已知尺寸的圆形图案代替棋盘图案。
• 几何线索：有时我们在场景中还有其他几何线索，例如可用于标定的直线和消失点。
• 基于深度学习的方法：当我们对成像设置几乎没有控制权时（例如，我们只有一个场景图像），仍然可以使用基于深度学习的方法获得相机的标定信息。

5.相机标定步骤

5.1 用棋盘图案定义真实世界的坐标

世界坐标系 ：我们的世界坐标由附在房间墙壁上的棋盘图案固定。我们的 3D 点是棋盘中正方形的角。上面棋盘的任意一个角都可以选择为世界坐标系的原点。$X$和$Y$轴沿墙，$Z$轴垂直于墙。因此，棋盘上的所有点都在 XY 平面上（即 $Z$= 0）。

在标定过程中，我们通过一组已知的 3D$(X_w,Y_w,Z_w)$ 点及其在图像中对应的像素位置$(u,v)$来计算相机参数。

对于 3D 点，我们在许多不同方向拍摄具有已知尺寸的棋盘图案。世界坐标附加到棋盘上，由于所有角点都位于一个平面上，我们选择每个点$Z_w$坐标为 0。因为点在棋盘中是等距的，所以每个3D点的$(X_w,Y_w)$坐标很容易定义，方法是取一个点作为参考$(0,0)$，并根据该参考点定义其余的点。

为什么棋盘图案在校准中得到如此广泛的应用?
棋盘图案在图像中是独特且易于检测的。不仅如此，棋盘上正方形的角对于定位它们来说是非常理想的，因为它们在两个方向上都有明显的梯度。此外，这些角也与棋盘线的交点有关。所有这些事实都被用来确定棋盘图案中正方形的角。

5.2 从不同的角度捕捉棋盘的多个图像

以上这些图像用于相机标定。

接下来，我们保持棋盘不动，并通过移动摄像机获取棋盘的多个图像。

或者，我们也可以保持相机不变，拍摄不同方向的棋盘图案。这两种情况在数学上是相似的。

5.3 查找棋盘的二维坐标

我们现在有多个棋盘图像。我们还知道棋盘上点在世界坐标中的 3D 位置。我们需要的最后一件事是图像中这些棋盘角的 2D 像素位置。

5.3.1 找到棋盘角

OpenCV 提供了一个名为 findChessboardCorners 的内置函数，它查找棋盘并返回角的坐标。让我们看看下面代码块中的用法。

C++

bool findChessboardCorners(InputArray image, Size patternSize, OutputArray corners, int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE )

Python

retval, corners = cv2.findChessboardCorners(image, patternSize, flags)

• image：源棋盘视图。它必须是 8 位灰度或彩色图像。
• patternSize： 每个棋盘行和列的内角数（ patternSize = cvSize (points_per_row, points_per_colum) = cvSize(columns,rows) ）。
• corners： 检测到角的输出数组。
• flags： 各种操作标志。只有当事情不顺利时，您才需要担心这些。使用默认值。

输出为true或false，取决于是否检测到棋盘格。

5.3.2 细化棋盘角

一切都是为了标定精度的。为了获得良好的结果，重要的是获得具有亚像素级别精度的角点位置。 OpenCV 的函数cornerSubPix 获取原始图像和角点位置，并在原始位置的一个小邻域内寻找最佳角点位置。该算法本质上是迭代的，因此我们需要指定终止标准（例如迭代次数和/或准确性）
C++

void cornerSubPix(InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)

Python

cv2.cornerSubPix(image, corners, winSize, zeroZone, criteria)

• image：输入图片。
• corners：输入角的初始坐标，输出提供的细化坐标。
• winSize： 搜索窗口边长的一半。
• zeroZone： 搜索区域中间的死亡区域的一半大小，下面的公式中没有对其求和。它有时用来避免自相关矩阵可能出现的奇点。(-1，-1)表示不存在该大小。
• criteria 终止角细化迭代过程的准则。也就是说，角位置细化过程在criteria.maxCount 迭代之后或在某个迭代中角位置移动小于criteria.epsilon 时停止。

5.4 相机标定

校准的最后一步是将世界坐标中的 3D 点及其在所有图像中的 2D 位置传递给 OpenCV 的 calibrateCamera 方法。该实现基于Zhengyou Zhang 的一篇论文。数学有点复杂，需要线性代数背景。

让我们看看 calibrateCamera 的语法

C++

double calibrateCamera(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs)

Python

retval, cameraMatrix, distCoeffs, rvecs, tvecs = cv2.calibrateCamera(objectPoints, imagePoints, imageSize)

• objectPoints: 3D 点向量的向量。 外部向量包含与视图数量一样多的元素。
• imagePoints: 二维图像点的向量。
• imageSize: 图像的大小
• cameraMatrix: 内在相机矩阵
• distCoeffs: 镜头畸变系数。这些系数将在以后的文章中解释。
• rvecs: 为 3×1 旋转向量。向量的方向指定旋转轴，向量的大小指定旋转角度。
• tvecs: 3×1 平移向量。

6.相机标定完整代码

下面分享了使用 Python 和 C++ 进行相机标定的代码。

6.1 用于相机标定的 Python 代码

请通读代码注释，它们解释了每个步骤的作用。

#!/usr/bin/env python

import cv2
import numpy as np
import os
import glob

# 定义棋盘格的尺寸
CHECKERBOARD = (6,9)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

# 创建向量以存储每个棋盘图像的 3D 点向量
objpoints = []
# 创建向量以存储每个棋盘图像的 2D 点向量
imgpoints = [] 


# 定义 3D 点的世界坐标
objp = np.zeros((1, CHECKERBOARD[0] * CHECKERBOARD[1], 3), np.float32)
objp[0,:,:2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)
prev_img_shape = None

# 提取存储在给定目录中的单个图像的路径
images = glob.glob('./images/*.jpg')
for fname in images:
    img = cv2.imread(fname)
    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    # 找到棋盘角
    # 如果在图像中找到所需数量的角，则 ret = true
    ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, cv2.CALIB_CB_ADAPTIVE_THRESH + cv2.CALIB_CB_FAST_CHECK + cv2.CALIB_CB_NORMALIZE_IMAGE)
    
    """
    如果检测到所需数量的角， 我们细化像素坐标并可视化
    """
    if ret == True:
        objpoints.append(objp)
        # 细化给定二维点的像素坐标。
        corners2 = cv2.cornerSubPix(gray, corners, (11,11),(-1,-1), criteria)
        
        imgpoints.append(corners2)

        # 绘制并显示角
        img = cv2.drawChessboardCorners(img, CHECKERBOARD, corners2, ret)
    
    cv2.imshow('img',img)
    cv2.waitKey(0)

cv2.destroyAllWindows()

h,w = img.shape[:2]

"""
通过传递已知 3D 点 (objpoints) 的值 和检测到的角点（imgpoints）对应的像素坐标 实现相机标定
"""
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

print("Camera matrix : \n")
print(mtx)
print("dist : \n")
print(dist)
print("rvecs : \n")
print(rvecs)
print("tvecs : \n")
print(tvecs)

6.2 用于相机标定的 C++ 代码

#include <opencv2/opencv.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <stdio.h>
#include <iostream>

// 定义棋盘的尺寸
int CHECKERBOARD[2]{6,9}; 

int main()
{
  // 创建向量以存储每个棋盘图像的 3D 点向量
  std::vector<std::vector<cv::Point3f> > objpoints;

  // 创建向量以存储每个棋盘图像的 2D 点向量
  std::vector<std::vector<cv::Point2f> > imgpoints;

  // 定义 3D 点的世界坐标
  std::vector<cv::Point3f> objp;
  for(int i{0}; i<CHECKERBOARD[1]; i++)
  {
    for(int j{0}; j<CHECKERBOARD[0]; j++)
      objp.push_back(cv::Point3f(j,i,0));
  }


  // 提取存储在给定目录中的单个图像的路径
  std::vector<cv::String> images;
  // 包含棋盘图像的文件夹的路径
  std::string path = "./images/*.jpg";

  cv::glob(path, images);

  cv::Mat frame, gray;
  // 用于存储检测到的棋盘角的像素坐标的向量
  std::vector<cv::Point2f> corner_pts;
  bool success;
  
  /* 循环遍历目录中的所有图像 */
  for(int i{0}; i<images.size(); i++)
  {
    frame = cv::imread(images[i]);
    cv::cvtColor(frame,gray,cv::COLOR_BGR2GRAY);

    // 寻找棋盘角
    // 如果在图像中找到所需数量的角，则成功 = true
    success = cv::findChessboardCorners(gray, cv::Size(CHECKERBOARD[0], CHECKERBOARD[1]), corner_pts, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FAST_CHECK | CV_CALIB_CB_NORMALIZE_IMAGE);
    
    /* 
     如果检测到所需数量的角，们细化像素坐标并在棋盘格图像上显示它们
    */
    if(success)
    {
      cv::TermCriteria criteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 30, 0.001);
      
      // 细化给定二维点的像素坐标。
      cv::cornerSubPix(gray,corner_pts,cv::Size(11,11), cv::Size(-1,-1),criteria);
      
      // 在棋盘上显示检测到的角点
      cv::drawChessboardCorners(frame, cv::Size(CHECKERBOARD[0], CHECKERBOARD[1]), corner_pts, success);
      
      objpoints.push_back(objp);
      imgpoints.push_back(corner_pts);
    }

    cv::imshow("Image",frame);
    cv::waitKey(0);
  }

  cv::destroyAllWindows();

  cv::Mat cameraMatrix,distCoeffs,R,T;

  /*通过传递已知 3D 点 (objpoints) 的值 和检测到的角点（imgpoints）对应的像素坐标 实现相机标定*/
  cv::calibrateCamera(objpoints, imgpoints, cv::Size(gray.rows,gray.cols), cameraMatrix, distCoeffs, R, T);

  std::cout << "cameraMatrix : " << cameraMatrix << std::endl;
  std::cout << "distCoeffs : " << distCoeffs << std::endl;
  std::cout << "Rotation vector : " << R << std::endl;
  std::cout << "Translation vector : " << T << std::endl;

  return 0;
}

参考目录

https://learnopencv.com/camera-calibration-using-opencv/