相关文章推荐
小百科  ›  python 使用相机内外参 解算坐标 python 相机标定_mob6454cc64e36b的技术博客_
pycharm python opencv 相机标定
有胆有识的便当
1 周前



OpenCV-Python 相机标定

  • 前言
  • 一、相机标定原理
  • 二、OpenCV 安装及 Pycharm 配置（macOS）
  • 1. OpenCV 安装
  • 2. Pycharm 安装及配置
  • 三、相机标定实例教程


前言

如题，我之前完全没接触过 OpenCV，对相机标定的原理也不了解，这篇文章是一个小白从零开始的学习历程，包括踩过的坑。

主要参考的资料包括：
[1] OpenCV 官方文档 [2]一个开源的视觉机械臂项目： hta0

一、相机标定原理

关于相机标定的原理，网上有很多资料，在此就不赘述了，我们主要讲实际操作。

如果对原理部分感兴趣的话，可以阅读这篇博客： Calculate X, Y, Z Real World Coordinates from Image Coordinates using OpenCV ，本文使用的代码也是源自 hta0 项目。

本文的主要目标，如下图所示：

python 使用相机内外参 解算坐标 python 相机标定_OpenCV


就是求出相机的 Distortion coefficients 和它的内参数：camera matrix

二、OpenCV 安装及 Pycharm 配置（macOS）

版本：macOS Big Sur 11.2.3

1. OpenCV 安装

首先，还是要把 OpenCV 安装好啦（我的版本是 OpenCV 4.5.1 ），详细教程见： Install OpenCV on MacOS

注意啦：我这篇教程是参考的网上的安装流程，所以也安装了 Xcode，主要是针对 OpenCV-C++， 如果只想用 OpenCV-Python 的话，可以省略这一步，直接安装 Pycharm 就好。

2. Pycharm 安装及配置

  • 安装
    Python IDE 我选择的是 Pycharm，安装方法我参考的是 这篇 ，如果想快速上手，可以直接在 Pycharm 官网下载，选择专业版试用（我的版本是 Pycharm 2020.3 ），反正也能用30天嘛
  • 配置
    (1) 首先创建一个 new project，如图项目名称为 pythonProject，点击 create 即可：

    (2) Pycharm - Preferences - Project - Python Interpreter，点击窗口左下角的 + ，搜索 opencv-python，numpy等包进行安装


    (3) 检查一下，在我们这个刚创建的 pythonProject 中的 main.py 中输入： 
import cv2

运行结果如下，说明配置成功：

python 使用相机内外参 解算坐标 python 相机标定_python_02


(4) 下面我们可以运行一个简单的例程， 利用 OpenCV 显示图片

在桌面创建图片：pic1.jpg，那么如何知道它的路径呢：右键显示简介，如图所示复制选中部分（即位置信息，粘贴后就是英文路径了）

python 使用相机内外参 解算坐标 python 相机标定_Desktop_03


在 main.py 中输入以下代码： 

import numpy as np
import cv2
img = cv2.imread("/Users/olefine/Desktop/pic1.jpg")  # 读取图片
cv2.imshow("image", img)  # 显示图片，命名为 image
cv2.waitKey(0)
cv2.destroyAllWindows()

运行结果如下（Pikachu被迫二次营业，嘻嘻）：

python 使用相机内外参 解算坐标 python 相机标定_Desktop_04

三、相机标定实例教程

这部分我们就要开始相机标定的实际操作啦
由于我还没有买相机，所以这次我们使用 hta0 项目中现成的棋盘格以及标定图片，后面买了相机之后会附上自己的标定过程

  1. 首先，从这里 [link] 把 hta0 项目 download 下来，我们只需要关注相机标定的部分，包括文件夹：camera_data（用于存储x，所以我们先把这个文件夹清空，运行了标定程序后会自动生成文件），calibration_images（40张不同角度的棋盘标定照片），和文件：initial_camera_calibration.py（标定程序）

python 使用相机内外参 解算坐标 python 相机标定_Desktop_05


各个文件（夹）用途说明：

python 使用相机内外参 解算坐标 python 相机标定_python 使用相机内外参 解算坐标_06

  1. 把下载的项目文件夹，重命名为 hta0，并存储在桌面，如图所示：

    calibration_images 文件夹，包含40张不同角度的棋盘格照片：
  2. 在 Pycharm 中打开程序
  • 打开项目：Desktop - hta0 - Open：
  • 打开程序：initial_camera_calibration.py

注意啦，有时候打开 .py 文件会出现右上角 run 按钮（绿色）是灰色的情况，这时候只要右键选择 Run就可以（如下图所示）：

python 使用相机内外参 解算坐标 python 相机标定_OpenCV_07

  • 修改程序中的路径
    打开程序后，还不能直接运行，我们需要修改一下代码中的几处路径：
    首先是 camera calibration files 的存储路径 
workingdir="/Users/olefine/Desktop/hta0/"
savedir="camera_data/"

python 使用相机内外参 解算坐标 python 相机标定_Desktop_08


还有棋盘格标定图片的路径，这里我改成绝对路径，不容易出错 

images = glob.glob("/Users/olefine/Desktop/hta0/calibration_images/*jpg")

python 使用相机内外参 解算坐标 python 相机标定_OpenCV_09


修改后的标定程序： 

import numpy as np
import cv2
import glob
import time
workingdir="/Users/olefine/Desktop/hta0/"
savedir="camera_data/"
# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)
objp = np.zeros((7*7,3), np.float32)
#add 2.5 to account for 2.5 cm per square in grid
objp[:,:2] = np.mgrid[0:7,0:7].T.reshape(-1,2)*2.5
# Arrays to store object points and image points from all the images.
objpoints = [] # 3d point in real world space
imgpoints = [] # 2d points in image plane.
images = glob.glob("/Users/olefine/Desktop/hta0/calibration_images/*jpg")
win_name="Verify"
cv2.namedWindow(win_name, cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty(win_name,cv2.WND_PROP_FULLSCREEN,cv2.WINDOW_FULLSCREEN)
print("getting images")
for fname in images:
    img = cv2.imread(fname)
    print(fname)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # Find the chess board corners
    ret, corners = cv2.findChessboardCorners(gray, (7,7), None)
    # If found, add object points, image points (after refining them)
    if ret == True:
        objpoints.append(objp)
        corners2=cv2.cornerSubPix(gray,corners, (11,11), (-1,-1), criteria)
        imgpoints.append(corners)
        # Draw and display the corners
        cv2.drawChessboardCorners(img, (7,7), corners2, ret)
        cv2.imshow(win_name, img)
        cv2.waitKey(500)
    img1=img
cv2.destroyAllWindows()
print(">==> Starting calibration")
ret, cam_mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)
#print(ret)
print("Camera Matrix")
print(cam_mtx)
np.save(savedir+'cam_mtx.npy', cam_mtx)
print("Distortion Coeff")
print(dist)
np.save(savedir+'dist.npy', dist)
print("r vecs")
print(rvecs[2])
print("t Vecs")
print(tvecs[2])
print(">==> Calibration ended")
h,  w = img1.shape[:2]
print("Image Width, Height")
print(w, h)
#if using Alpha 0, so we discard the black pixels from the distortion.  this helps make the entire region of interest is the full dimensions of the image (after undistort)
#if using Alpha 1, we retain the black pixels, and obtain the region of interest as the valid pixels for the matrix.
#i will use Apha 1, so that I don't have to run undistort.. and can just calculate my real world x,y
newcam_mtx, roi=cv2.getOptimalNewCameraMatrix(cam_mtx, dist, (w,h), 1, (w,h))
print("Region of Interest")
print(roi)
np.save(savedir+'roi.npy', roi)
print("New Camera Matrix")
#print(newcam_mtx)
np.save(savedir+'newcam_mtx.npy', newcam_mtx)
print(np.load(savedir+'newcam_mtx.npy'))
inverse = np.linalg.inv(newcam_mtx)
print("Inverse New Camera Matrix")
print(inverse)
# undistort
undst = cv2.undistort(img1, cam_mtx, dist, None, newcam_mtx)
# crop the image
#x, y, w, h = roi
#dst = dst[y:y+h, x:x+w]
#cv2.circle(dst,(308,160),5,(0,255,0),2)
cv2.imshow('img1', img1)
cv2.waitKey(5000)      
cv2.destroyAllWindows()
cv2.imshow('img1', undst)
cv2.waitKey(5000)      
cv2.destroyAllWindows()
  • 运行结果 
>==> Starting calibration
Camera Matrix
[[1.11378508e+03 0.00000000e+00 6.38266808e+02]
 [0.00000000e+00 1.09831926e+03 3.46949583e+02]
 [0.00000000e+00 0.00000000e+00 1.00000000e+00]]
Distortion Coeff
[[ 0.31573236 -0.92321187 -0.01570854 -0.01086439  1.31794916]]
r vecs
[[-0.28537416]
 [ 0.18506598]
 [ 1.07466093]]
t Vecs
[[ -3.84482279]
 [-12.7104052 ]
 [ 47.74969689]]
>==> Calibration ended
Image Width, Height
1280 720
Region of Interest
(13, 19, 1253, 688)
New Camera Matrix
[[1.16301404e+03 0.00000000e+00 6.27550607e+02]
 [0.00000000e+00 1.12108057e+03 3.41597143e+02]
 [0.00000000e+00 0.00000000e+00 1.00000000e+00]]
Inverse New Camera Matrix
[[ 8.59834849e-04  0.00000000e+00 -5.39589882e-01]
 [ 0.00000000e+00  8.91996552e-04 -3.04703474e-01]
 [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]
Process finished with exit code 0

结果中的 New Camera Matrix 就是我们需要的 camera matrix，同时 camera calibration files 也存储到了 camera_data 文件夹中：

python 使用相机内外参 解算坐标 python 相机标定_python_10


这样，相机初步标定就完成啦，有空会更新标定代码的解读，视觉机械臂有关的博客会随着毕业设计进程更新


java 线程池中启动timer

引言 我相信大家面试的时候都遇到过线程池有关的问题，这个问题被问到的频率很高，如果你不了解，或者仅仅是简单的了解的话，还是好好研究研究吧，因为它真的很有意思。线程池的意义我们有时候为了方便或者写一个测试的时候会这样启动一个线程：new Thread(new Runnable() { @Override public void run() {

 
推荐文章
Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
小百科 - 百科知识指南