OpenCV相机标定的全过程记录

目录
  • 一、OpenCV标定的几个常用函数
    • findChessboardCorners()棋盘格角点检测
    • cv::drawChessboardCorners()棋盘格角点的绘制
    • find4QuadCornerSubpix()对粗提取的角点进行精确化
    • cornerSubPix()亚像素检测
    • calibrateCamera()求解摄像机的内在参数和外在参数
    • initUndistortRectifyMap()计算畸变参数
  • 二、绘制棋盘格,拍摄照片
  • 三、相机标定
  • 四、对图片进行校正
  • 总结

一、OpenCV标定的几个常用函数

findChessboardCorners() 棋盘格角点检测

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

第一个参数是输入的棋盘格图像(可以是8位单通道或三通道图像);

第二个参数是棋盘格内部的角点的行列数(注意:不是棋盘格的行列数,如棋盘格的行列数分别为4、8,而内部角点的行列数分别是3、7,因此这里应该指定为cv::Size(3, 7));

第三个参数是检测到的棋盘格角点,类型为std::vectorcv::Point2f。

第四个参数flag,用于指定在检测棋盘格角点的过程中所应用的一种或多种过滤方法,可以使用下面的一种或多种,如果都是用则使用OR:

  • cv::CALIB_CB_ADAPTIVE_THRESH:使用自适应阈值将图像转化成二值图像
  • cv::CALIB_CB_NORMALIZE_IMAGE:归一化图像灰度系数(用直方图均衡化或者自适应阈值)
  • cv::CALIB_CB_FILTER_QUADS:在轮廓提取阶段,使用附加条件排除错误的假设
  • cv::CALIB_CV_FAST_CHECK:快速检测

cv::drawChessboardCorners() 棋盘格角点的绘制

drawChessboardCorners( InputOutputArray image,
                           Size patternSize,
                           InputArray corners,
                           bool patternWasFound );
  • image为8-bit,三通道图像
  • patternSize,每一行每一列的角
  • corners,已经检测到的角
  • patternWasFound,findChessboardCorners的返回值

find4QuadCornerSubpix() 对粗提取的角点进行精确化

find4QuadCornerSubpix( InputArray img,
                           InputOutputArray corners,
                           Size region_size );
  • image源图像
  • corners,提供角点的初始坐标
  • region_size: 搜索窗口的一般尺寸

cornerSubPix() 亚像素检测

void cornerSubPix( InputArray image,
                       InputOutputArray corners,
                       Size winSize,
                       Size zeroZone,
                       TermCriteria criteria );
  • image源图像
  • corners,提供角点的初始坐标,返回更加精确的点
  • winSize,搜索窗口的一般尺寸,如果winSize=Size(5,5),则search windows为11*11
  • winSize,死区的一般尺寸,用来避免自相关矩阵的奇点,(-1,-1)表示没有死区
  • criteria,控制迭代次数和精度

calibrateCamera() 求解摄像机的内在参数和外在参数

double calibrateCamera( InputArrayOfArrays objectPoints,
                            InputArrayOfArrays imagePoints,
                            Size imageSize,
                            InputOutputArray cameraMatrix,
                            InputOutputArray distCoeffs,
                            OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
                            int flags = 0,
                            TermCriteria criteria = TermCriteria(TermCriteria::COUNT +
                            TermCriteria::EPS, 30, DBL_EPSILON) );

objectPoints,世界坐标,用vector<vector>,输入x,y坐标,z坐标为0

imagePoints,图像坐标,vector<vector>

imageSize,图像的大小用于初始化标定摄像机的image的size

cameraMatrix,内参数矩阵

distCoeffs,畸变矩阵

rvecs,位移向量

tvecs,旋转向量

flags,可以组合:

CV_CALIB_USE_INTRINSIC_GUESS:使用该参数时,将包含有效的fx,fy,cx,cy的估计值的内参矩阵cameraMatrix,作为初始值输入,然后函数对其做进一步优化。如果不使用这个参数,用图像的中心点初始化光轴点坐标(cx, cy),使用最小二乘估算出fx,fy(这种求法好像和张正友的论文不一样,不知道为何要这样处理)。注意,如果已知内部参数(内参矩阵和畸变系数),就不需要使用这个函数来估计外参,可以使用solvepnp()函数计算外参数矩阵。

CV_CALIB_FIX_PRINCIPAL_POINT:在进行优化时会固定光轴点,光轴点将保持为图像的中心点。当CV_CALIB_USE_INTRINSIC_GUESS参数被设置,保持为输入的值。

CV_CALIB_FIX_ASPECT_RATIO:固定fx/fy的比值,只将fy作为可变量,进行优化计算。当
CV_CALIB_USE_INTRINSIC_GUESS没有被设置,fx和fy的实际输入值将会被忽略,只有fx/fy的比值被计算和使用。

CV_CALIB_ZERO_TANGENT_DIST:切向畸变系数(P1,P2)被设置为零并保持为零。

CV_CALIB_FIX_K1,…,CV_CALIB_FIX_K6:对应的径向畸变系数在优化中保持不变。如果设置了CV_CALIB_USE_INTRINSIC_GUESS参数,就从提供的畸变系数矩阵中得到。否则,设置为0。

CV_CALIB_RATIONAL_MODEL(理想模型):启用畸变k4,k5,k6三个畸变参数。使标定函数使用有理模型,返回8个系数。如果没有设置,则只计算其它5个畸变参数。

CALIB_THIN_PRISM_MODEL (薄棱镜畸变模型):启用畸变系数S1、S2、S3和S4。使标定函数使用薄棱柱模型并返回12个系数。如果不设置标志,则函数计算并返回只有5个失真系数。

CALIB_FIX_S1_S2_S3_S4 :优化过程中不改变薄棱镜畸变系数S1、S2、S3、S4。如果cv_calib_use_intrinsic_guess设置,使用提供的畸变系数矩阵中的值。否则,设置为0。

CALIB_TILTED_MODEL (倾斜模型):启用畸变系数tauX and tauY。标定函数使用倾斜传感器模型并返回14个系数。如果不设置标志,则函数计算并返回只有5个失真系数。

CALIB_FIX_TAUX_TAUY :在优化过程中,倾斜传感器模型的系数不被改变。如果cv_calib_use_intrinsic_guess设置,从提供的畸变系数矩阵中得到。否则,设置为0。

initUndistortRectifyMap() 计算畸变参数

void initUndistortRectifyMap(InputArray cameraMatrix,
                                InputArray distCoeffs,
                                InputArray R,
                                InputArray newCameraMatrix,
                                Size size,
                                int m1type,
                                OutputArray map1,
                                OutputArray map2)
  • cameraMatrix,摄像机内参数矩阵
  • distCoeffs, 摄像机的5个畸变系数,(k1,k2,p1,p2[,k3[,k4,k5,k6]])
  • R,在客观空间中的转换对象
  • newCameraMatrix,新的3*3的浮点型矩矩阵
  • size,为失真图像的大小
  • m1type,第一个输出的map,类型为CV_32FC1或CV_16SC2
  • map1,x映射函数
  • map2,y映射函数

二、绘制棋盘格,拍摄照片

这里自己画一个棋盘格用作标定,长度为1280像素,宽490像素,横向10方格,纵向7方格

std_cb = Vision::makeCheckerboard(1280, 490, 10, 7, 0,
(char *)"../blizzard/res/calibration/std_cb.png");

效果如图

Vision是我个人创建的视觉类,可以用来绘制标准的棋盘格。

头文件vision.h

//
// Created by czh on 18-10-16.
//
#ifndef OPENGL_PRO_VISION_H
#define OPENGL_PRO_VISION_H

#include "opencv2/opencv.hpp"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgcodecs/imgcodecs.hpp>

#include "iostream"

class Vision {
public:
    static cv::Mat read(std::string file_path, int flags = cv::IMREAD_ANYCOLOR | cv::IMREAD_ANYDEPTH);

    static cv::Mat write(std::string file_path, int flags = cv::IMREAD_ANYCOLOR | cv::IMREAD_ANYDEPTH);

    static void dispConfig(cv::Mat img);

    static cv::Mat makeCheckerboard(int bkgWidth, int bkgHeight, int sqXnum, int sqYnum = 0, int borderThickness = 0, char *savePath = NULL);
private:

};
#endif //OPENGL_PRO_VISION_H

源文件vision.cpp

//
// Created by czh on 18-10-16.
//

#include "vision.h"
#include "string.h"

using namespace std;
using namespace cv;

const char *findName(const char *ch) {
    const char *name = strrchr(ch, '/');
    return ++name;
}

cv::Mat Vision::read(std::string file_path, int flags) {
    printf("#Vision read\n");
    cv::Mat img;
    img = cv::imread(file_path, flags);
    if (img.data == NULL) {
        printf("\tError:vision read\n");
    } else {
        dispConfig(img);
    }
    return img;
}

void Vision::dispConfig(cv::Mat img) {
    printf("\tpixel:%d*%d, channels:%d\n", img.size().width, img.size().height, img.channels());
}

cv::Mat Vision::makeCheckerboard(int bkgWidth, int bkgHeight, int sqXnum, int sqYnum, int thickNum, char *savePath) {
    if(sqYnum == 0){
        sqYnum = sqXnum;
    }
    if(savePath == NULL){
        char *defaultPath = (char *)"../res/calibration/maths.png";
        savePath = defaultPath;
    }
    int checkboardX = 0;//棋盘x坐标
    int checkboardY = 0;//棋盘y坐标
    int xLen = bkgWidth / sqXnum;//x方格长度
    int yLen = bkgHeight / sqYnum;//y方格长度
    cv::Mat img(bkgHeight + thickNum * 2, bkgWidth + thickNum * 2, CV_8UC4, cv::Scalar(0, 255, 255, 255));
    for (int i = 0; i < img.rows; i++) {

        for (int j = 0; j < img.cols; j++) {

            if (i < thickNum || i >= thickNum + bkgHeight || j < thickNum || j >= thickNum + bkgWidth) {
                img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                continue;
            }
            checkboardX = j - thickNum;
            checkboardY = i - thickNum;
            if (checkboardY / yLen % 2 == 0) {
                if ((checkboardX) / xLen % 2 == 0) {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(255, 255, 255, 255);
                } else {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                }
            }
            else{
                if ((checkboardX) / xLen % 2 != 0) {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(255, 255, 255, 255);
                } else {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                }
            }
        }
    }
    imwrite(savePath, img);    //保存生成的图片
    printf("#makeCheckerboard %d*%d\n", bkgWidth + thickNum, bkgHeight + thickNum);
    return img;
}

用A4纸打印棋盘格,相机拍摄照片。

我偷懒,拿了别人的标定照片

三、相机标定

下面是相机标定代码

cv::imwrite("../blizzard/res/calibration/cb_source.png", cb_source);

    printf("#Start scan corner\n");
    cv::Mat img;
    std::vector<cv::Point2f> image_points;
    std::vector<std::vector<cv::Point2f>> image_points_seq; /* 保存检测到的所有角点 */
    if (cv::findChessboardCorners(cb_source, cv::Size(aqXnum, aqYnum), image_points, 0) == 0) {
        printf("#Error: Corners not find ");
        return 0;
    } else {
        cvtColor(cb_source, img, CV_RGBA2GRAY);
        cv::imwrite("../blizzard/res/calibration/cb_gray.png", img);
        //find4QuadCornerSubpix(img, image_points, cv::Size(5, 5));

        cv::cornerSubPix(img, image_points, cv::Size(11, 11), cv::Size(-1, -1),
                         cv::TermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 30, 0.01));

        image_points_seq.push_back(image_points);

        cv::Mat cb_corner;
        cb_corner = cb_source.clone();
        drawChessboardCorners(cb_corner, cv::Size(aqXnum, aqYnum), image_points, true);
        cv::imwrite("../blizzard/res/calibration/cb_corner.png", cb_corner);
    }

    printf("#Start calibrate\n");
    cv::Size square_size = cv::Size(14.2222, 12);
    std::vector<std::vector<cv::Point3f>> object_points; /* 保存标定板上角点的三维坐标 */
    cv::Mat cameraMatrix = cv::Mat(3, 3, CV_32FC1, cv::Scalar::all(0)); /* 摄像机内参数矩阵 */
    cv::Mat distCoeffs = cv::Mat(1, 5, CV_32FC1, cv::Scalar::all(0)); /* 摄像机的5个畸变系数:k1,k2,p1,p2,k3 */
    std::vector<cv::Mat> tvecsMat;  /* 每幅图像的旋转向量 */
    std::vector<cv::Mat> rvecsMat;  /* 每幅图像的平移向量 */

    std::vector<cv::Point3f> realPoint;
    for (int i = 0; i < aqYnum; i++) {
        for (int j = 0; j < aqXnum; j++) {
            cv::Point3f tempPoint;
            /* 假设标定板放在世界坐标系中z=0的平面上 */
            tempPoint.x = i * square_size.width;
            tempPoint.y = j * square_size.height;
            tempPoint.z = 0;
            realPoint.push_back(tempPoint);
        }
    }
    object_points.push_back(realPoint);

    printf("#objectPoints: %ld\n", sizeof(object_points[0]));
    std::cout << object_points[0] << std::endl;

    printf("#image_points: %ld\n", sizeof(image_points_seq[0]));
    std::cout << image_points << std::endl;

    printf("#image size\n");
    std::cout << SCREEN_WIDTH << "*" << SCREEN_HEIGHT << std::endl;

    cv::calibrateCamera(object_points, image_points_seq, cb_source.size(), cameraMatrix, distCoeffs, rvecsMat, tvecsMat,
                        CV_CALIB_FIX_K3);

    std::cout << "tvecsMat:\n" << tvecsMat[0] << std::endl;
    std::cout << "rvecsMat:\n" << rvecsMat[0] << std::endl;

    std::cout << "#cameraMatrix:\n" << cameraMatrix << std::endl;
    std::cout << "#distCoeffs:\n" << distCoeffs << std::endl;

四、对图片进行校正

	cv::Mat cb_final;

    cv::Mat mapx = cv::Mat(cb_source.size(), CV_32FC1);
    cv::Mat mapy = cv::Mat(cb_source.size(), CV_32FC1);
    cv::Mat R = cv::Mat::eye(3, 3, CV_32F);
    //initUndistortRectifyMap(cameraMatrix, distCoeffs, R, cv::Mat(), cb_source.size(), CV_32FC1,
    //                        mapx, mapy);
    //cv::remap(cb_source, cb_final, mapx, mapy, cv::INTER_LINEAR);

    undistort(cb_source, cb_final, cameraMatrix, distCoeffs);

    cv::imwrite("../blizzard/res/calibration/cb_final.png", cb_final);

1.校正前的图片

2.校正后的图片

总结

到此这篇关于OpenCV相机标定的文章就介绍到这了,更多相关OpenCV相机标定内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 基于python opencv单目相机标定的示例代码

    相机固定不动,通过标定版改动不同方位的位姿进行抓拍 import cv2 camera=cv2.VideoCapture(1) i = 0 while 1: (grabbed, img) = camera.read() cv2.imshow('img',img) if cv2.waitKey(1) & 0xFF == ord('j'): # 按j保存一张图片 i += 1 u = str(i) firename=str('./img'+u+'.jpg') cv2.imwrite(firename

  • Python opencv相机标定实现原理及步骤详解

    相机标定相机标定的目的 获取摄像机的内参和外参矩阵(同时也会得到每一幅标定图像的选择和平移矩阵),内参和外参系数可以对之后相机拍摄的图像就进行矫正,得到畸变相对很小的图像. 相机标定的输入 标定图像上所有内角点的图像坐标,标定板图像上所有内角点的空间三维坐标(一般情况下假定图像位于Z=0平面上). 相机标定的输出 摄像机的内参.外参系数. 拍摄的物体都处于三维世界坐标系中,而相机拍摄时镜头看到的是三维相机坐标系,成像时三维相机坐标系向二维图像坐标系转换.不同的镜头成像时的转换矩阵不同,同时可能引

  • OpenCV实现相机标定示例详解

    目录 环境准备 相机标定 棋盘格图片 实时显示相机的画面 在线标定 实时显示相机画面,按键保存能检测到角点的 棋盘格图片 离线标定 畸变矫正 环境准备 vs2015+opencv4.10安装与配置 相机标定 棋盘格图片 可以自己生成,然后打印到A4纸上.(也可以去TB买一块,平价买亚克力板的,不反光买氧化铝材质,高精度买陶瓷的) /** * 生成棋盘格图片 **/ int generateCalibrationPicture() { //Mat frame = imread("3A4.bmp&q

  • 聊一聊OpenCV相机标定

    相机标定:简单的说,就是获得相机参数的过程.参数如:相机内参数矩阵,投影矩阵,旋转矩阵和平移矩阵等 什么叫相机参数? 简单的说,将现实世界中的人.物,拍成一张图像(二维).人或物在世界中的三维坐标,和图像上对应的二维坐标间的关系.表达两种不同维度坐标间的关系用啥表示?用相机参数. 相机的成像原理 先来看一下,相机的成像原理: 如图所示,这是一个相机模型.将物体简化看成一个点.来自物体的光,通过镜头,击中图像平面(图像传感器),以此成像.d0是物体到镜头的距离,di时镜头到图像平面的距离,f是镜头

  • OpenCV实现相机标定板

    本文实例为大家分享了OpenCV实现相机标定板的具体代码,供大家参考,具体内容如下 1.代码实现 #include <opencv.hpp> #include "highgui.h" #include "cxcore.h" using namespace cv; int main0(int argc, char *argv[]) { int width = 140;//width and heigth of single square int heigh

  • OpenCV相机标定的全过程记录

    目录 一.OpenCV标定的几个常用函数 findChessboardCorners()棋盘格角点检测 cv::drawChessboardCorners()棋盘格角点的绘制 find4QuadCornerSubpix()对粗提取的角点进行精确化 cornerSubPix()亚像素检测 calibrateCamera()求解摄像机的内在参数和外在参数 initUndistortRectifyMap()计算畸变参数 二.绘制棋盘格,拍摄照片 三.相机标定 四.对图片进行校正 总结 一.OpenCV

  • Python使用OpenCV进行标定

    本文结合OpenCV官方样例,对官方样例中的代码进行修改,使其能够正常运行,并对自己采集的数据进行实验和讲解. 一.准备 OpenCV使用棋盘格板进行标定,如下图所示.为了标定相机,我们需要输入一系列三维点和它们对应的二维图像点.在黑白相间的棋盘格上,二维图像点很容易通过角点检测找到.而对于真实世界中的三维点呢?由于我们采集中,是将相机放在一个地方,而将棋盘格定标板进行移动变换不同的位置,然后对其进行拍摄.所以我们需要知道(X,Y,Z)的值.但是简单来说,我们定义棋盘格所在平面为XY平面,即Z=

  • OpenCV实现相机标定

    本文实例为大家分享了OpenCV实现相机标定的具体代码,供大家参考,具体内容如下 一.相机与针孔相机模型 1.相机模型 现代科技加持下的相机已经成为制造精密设计巧妙的消费品,相机的光学结构也比诞生之初复杂了许多典型单反相机光学结构: 在众多相机模型中,针孔相机又称投影相机模型是相对简单而常用的模型.简单的说,针孔相机模型就是把相机简化成单纯的小孔成像,可想而知,这种简化对于精度要求高的情况或者特殊镜头的相机是不适用的.小孔成像原理: 2.引入透镜 单纯的小孔成像模型中没有考虑镜头,现实条件下,由

  • opencv 摄像机标定的实现

    原图 矫正后 我新建了个jz的文件夹放相机矫正所需要拍摄的图片,如下:共12张 # coding:utf-8 import cv2 import numpy as np import glob # 找棋盘格角点 # 阈值 criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) # 棋盘格模板规格 从0开始计算 w = 9 h = 6 # 世界坐标系中的棋盘格点,例如(0,0,0), (1,0,0), (

  • Qt Creator配置opencv环境的全过程记录

    首先需要下载好相应的opencv+控件文件夹(注意不要有中文和空格): 到文件夹下的x86/bin 目录中拷贝所有的.dll文件(建议选择按类型排序,否则有可能拷贝漏了) 复制到C:\Windows\SysWOW64下 使用: 在Qt Creator 中创建新工程,在工程中的.pro文件添加两行: INCLUDEPATH += D:/Qt_Opencv_Project/opencv_3.4.2_Qt/include LIBS += D:/Qt_Opencv_Project/opencv_3.4.

随机推荐