Python utilise OpenCV pour l'étalonnage

Cet article présente principalement l'utilisation d'OpenCV pour le calibrage en Python. Maintenant, je le partage avec tout le monde. Les amis dans le besoin peuvent s'y référer

Cet article combine les exemples officiels d'OpenCV. fournissez un échantillon officiel. Modifiez le code dans l'exemple afin qu'il puisse fonctionner normalement et effectuez des expériences et des explications sur les données que vous avez collectées.

1. Préparation

OpenCV utilise un damier pour le calibrage, comme le montre la figure ci-dessous. Afin de calibrer la caméra, nous devons saisir une série de points 3D et leurs points d'image 2D correspondants. Sur un damier noir et blanc, les points d'image bidimensionnels sont facilement trouvés grâce à la détection des coins. Qu’en est-il des points tridimensionnels dans le monde réel ? Au cours de notre collecte, nous avons placé l'appareil photo au même endroit, déplacé la plaque d'étalonnage en damier dans différentes positions, puis l'avons photographié. Nous devons donc connaître la valeur de (X,Y,Z). Mais pour faire simple, on définit le plan où se situe le damier comme le plan XY, c'est-à-dire Z=0. Pour le tableau d'étalonnage, nous pouvons connaître la taille du carré du damier, par exemple 30 mm, nous pouvons donc définir les coordonnées des points d'angle sur le damier comme (0,0,0), (30,0,0), ( 60, 0,0),..., l'unité de ce résultat est le mm.

Les points 3D sont appelés points objets, et les points image 2D sont appelés points image.

2. Détection des points d'angle du damier

Afin de trouver le modèle de damier, nous utilisons openCV La fonction cv2.findChessboardCorners(). Nous devons également indiquer au programme quelles sont les spécifications du modèle que nous utilisons, comme un damier 8*8 ou un damier 5*5. Il est recommandé d'utiliser un modèle de damier avec des nombres inégaux dans les directions x et y. Dans l'expérience suivante, nous utilisons un damier 10*7. Chaque carré a une longueur de côté de 20 mm, ce qui signifie qu'il contient 9*6 coins internes. Si cette fonction détecte le modèle, elle renverra le point d'angle correspondant et renverra true. Bien entendu, toutes les images ne parviennent pas à trouver le modèle requis, nous pouvons donc utiliser plusieurs images pour l'étalonnage. En plus d'utiliser un damier, nous pouvons également utiliser une matrice de points, et la fonction correspondante est cv2.findCirclesGrid().

Après avoir trouvé le point d'angle, nous pouvons utiliser cv2.cornerSubPix() pour obtenir des coordonnées plus précises des pixels d'angle. Nous pouvons également utiliser cv2.drawChessboardCorners() pour dessiner les coins sur l'image à afficher. Comme le montre la figure ci-dessous :

3. Par les étapes ci-dessus. , nous obtenons les points tridimensionnels utilisés pour l'étalonnage et les paires de points bidimensionnels correspondantes sur l'image. Nous utilisons cv2.calibrateCamera() pour l'étalonnage. Cette fonction renverra le résultat de l'étalonnage, la matrice des paramètres internes de la caméra, le coefficient de distorsion, la matrice de rotation et le vecteur de translation.

4. Dé-distorsion

Dans la troisième étape, nous avons obtenu les paramètres intrinsèques de la caméra et les coefficients de distorsion. image, nous pouvons également utiliser cv.getOptimalNewCameraMatrix() pour optimiser les paramètres internes et les coefficients de distorsion en définissant le facteur d'échelle libre alpha. Lorsque alpha est défini sur 0, un paramètre interne tronqué et un coefficient de distorsion qui supprime les pixels indésirables après la dédistorsion seront renvoyés ; lorsque alpha est défini sur 1, un paramètre interne tronqué contenant des paramètres et des coefficients de distorsion supplémentaires sera renvoyé. un retour sur investissement pour le recadrer. Ensuite, nous pouvons utiliser la matrice de paramètres internes et le coefficient de distorsion nouvellement obtenus pour déformer l'image. Il existe deux méthodes pour supprimer la distorsion :

(1) Utilisez cv2.undistort()

C'est la méthode la plus directe, appelez simplement la fonction directement. image, qui peut être recadrée en utilisant le ROI ci-dessus. Le code est le suivant :

L'image suivante montre le résultat de la dédistorsion d'une image et de la conservation des pixels noirs :

# undistort
dst = cv2.undistort(img, mtx, dist, None, newcameramtx)

# crop the image
x,y,w,h = roi
dst = dst[y:y+h, x:x+w]
cv2.imwrite('calibresult.png',dst)

(2) Utiliser le remmaping

Il s'agit d'une méthode en deux étapes, calculez d'abord un mappage de l'image déformée à l'image non déformée image, puis utilisez Cette relation de mappage déforme l'image. Le code est le suivant :

# undistort
mapx,mapy = cv2.initUndistortRectifyMap(mtx,dist,None,newcameramtx,(w,h),5)
dst = cv2.remap(img,mapx,mapy,cv2.INTER_LINEAR)

# crop the image
x,y,w,h = roi
dst = dst[y:y+h, x:x+w]
cv2.imwrite('calibresult.png',dst)

5. Erreur de rétroprojection

En rétroprojectant l'erreur, on peut évaluer la qualité des résultats. Plus le résultat est proche de 0, plus le résultat est idéal. À l'aide de la matrice de paramètres internes, du coefficient de distorsion, de la matrice de rotation et du vecteur de translation précédemment calculés, utilisez cv2.projectPoints() pour calculer la projection du point tridimensionnel sur l'image bidimensionnelle, puis calculez l'erreur entre le point obtenu par rétroprojection et le point détecté sur l'image. Enfin, une erreur moyenne pour toutes les images de calibrage est calculée, et cette valeur est l'erreur de rétroprojection. Code

Le code de toutes les étapes est le suivant :

Recommandations associées :

#coding:utf-8
import cv2
import numpy as np
import glob

# 找棋盘格角点
# 阈值
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
#棋盘格模板规格
w = 9
h = 6
# 世界坐标系中的棋盘格点,例如(0,0,0), (1,0,0), (2,0,0) ....,(8,5,0)，去掉Z坐标，记为二维矩阵
objp = np.zeros((w*h,3), np.float32)
objp[:,:2] = np.mgrid[0:w,0:h].T.reshape(-1,2)
# 储存棋盘格角点的世界坐标和图像坐标对
objpoints = [] # 在世界坐标系中的三维点
imgpoints = [] # 在图像平面的二维点

images = glob.glob('calib/*.png')
for fname in images:
 img = cv2.imread(fname)
 gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
 # 找到棋盘格角点
 ret, corners = cv2.findChessboardCorners(gray, (w,h),None)
 # 如果找到足够点对，将其存储起来
 if ret == True:
  cv2.cornerSubPix(gray,corners,(11,11),(-1,-1),criteria)
  objpoints.append(objp)
  imgpoints.append(corners)
  # 将角点在图像上显示
  cv2.drawChessboardCorners(img, (w,h), corners, ret)
  cv2.imshow('findCorners',img)
  cv2.waitKey(1)
cv2.destroyAllWindows()

# 标定
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None)

# 去畸变
img2 = cv2.imread('calib/00169.png')
h, w = img2.shape[:2]
newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h)) # 自由比例参数
dst = cv2.undistort(img2, mtx, dist, None, newcameramtx)
# 根据前面ROI区域裁剪图片
#x,y,w,h = roi
#dst = dst[y:y+h, x:x+w]
cv2.imwrite('calibresult.png',dst)

# 反投影误差
total_error = 0
for i in xrange(len(objpoints)):
 imgpoints2, _ = cv2.projectPoints(objpoints[i], rvecs[i], tvecs[i], mtx, dist)
 error = cv2.norm(imgpoints[i],imgpoints2, cv2.NORM_L2)/len(imgpoints2)
 total_error += error
print "total error: ", total_error/len(objpoints)

Les données dans OpenCVcv::Mat sont écrites dans le fichier txt

Opérations de lecture et d'écriture des données des fichiers OpenCV cv.Mat et .txt

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!