Calibración de cámara con Python – OpenCV

Requisitos previos: OpenCV

Una cámara es una parte integral de varios dominios como la robótica, la exploración espacial, etc. La cámara juega un papel importante. Ayuda a capturar todos y cada uno de los momentos y es útil para muchos análisis. Para utilizar la cámara como sensor visual, debemos conocer los parámetros de la cámara. La calibración de la cámara no es más que estimar los parámetros de una cámara, los parámetros de la cámara son necesarios para determinar una relación precisa entre un punto 3D en el mundo real y su correspondiente proyección 2D (píxel) en la imagen capturada por esa cámara calibrada.

Necesitamos considerar tanto los parámetros internos como la distancia focal, el centro óptico y los coeficientes de distorsión radial de la lente, etc., como los parámetros externos como la rotación y la traslación de la cámara con respecto a algún sistema de coordenadas del mundo real.

Bibliotecas requeridas:

• La biblioteca OpenCV  en python es una biblioteca de visión por computadora, utilizada principalmente para procesamiento de imágenes, procesamiento y análisis de video, reconocimiento y detección facial, etc.
• Numpy  es un paquete de procesamiento de arrays de propósito general. Proporciona un objeto de array multidimensional de alto rendimiento y herramientas para trabajar con estas arrays.

La calibración de la cámara se puede realizar paso a paso:

• Paso 1: primero defina las coordenadas del mundo real de los puntos 3D utilizando el tamaño conocido del patrón de tablero de ajedrez.
• Paso 2: Se capturan diferentes puntos de vista de la imagen del tablero de ajedrez.
• Paso 3: findChessboardCorners() es un método en OpenCV y se usa para encontrar coordenadas de píxeles (u, v) para cada punto 3D en diferentes imágenes
• Paso 4: Luego se usa el método calibrateCamera() para encontrar los parámetros de la cámara.

Tomará nuestro calculado (tres puntos, dos puntos, grayColor.shape[::-1], Ninguno, Ninguno) como parámetros y devolverá una lista con elementos como array de cámara, coeficiente de distorsión, vectores de rotación y vectores de traducción. 

Camera Matrix ayuda a transformar puntos de objetos 3D en puntos de imagen 2D y el coeficiente de distorsión devuelve la posición de la cámara en el mundo, con los valores de los vectores de rotación y traslación.

A continuación se muestra el programa completo del enfoque anterior:

# Import required modules
import cv2
import numpy as np
import os
import glob
 
 
# Define the dimensions of checkerboard
CHECKERBOARD = (6, 9)
 
 
# stop the iteration when specified
# accuracy, epsilon, is reached or
# specified number of iterations are completed.
criteria = (cv2.TERM_CRITERIA_EPS +
            cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
 
 
# Vector for 3D points
threedpoints = []
 
# Vector for 2D points
twodpoints = []
 
 
#  3D points real world coordinates
objectp3d = np.zeros((1, CHECKERBOARD[0]
                      * CHECKERBOARD[1],
                      3), np.float32)
objectp3d[0, :, :2] = np.mgrid[0:CHECKERBOARD[0],
                               0:CHECKERBOARD[1]].T.reshape(-1, 2)
prev_img_shape = None
 
 
# Extracting path of individual image stored
# in a given directory. Since no path is
# specified, it will take current directory
# jpg files alone
images = glob.glob('*.jpg')
 
for filename in images:
    image = cv2.imread(filename)
    grayColor = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
    # Find the chess board corners
    # If desired number of corners are
    # found in the image then ret = true
    ret, corners = cv2.findChessboardCorners(
                    grayColor, CHECKERBOARD,
                    cv2.CALIB_CB_ADAPTIVE_THRESH
                    + cv2.CALIB_CB_FAST_CHECK +
                    cv2.CALIB_CB_NORMALIZE_IMAGE)
 
    # If desired number of corners can be detected then,
    # refine the pixel coordinates and display
    # them on the images of checker board
    if ret == True:
        threedpoints.append(objectp3d)
 
        # Refining pixel coordinates
        # for given 2d points.
        corners2 = cv2.cornerSubPix(
            grayColor, corners, (11, 11), (-1, -1), criteria)
 
        twodpoints.append(corners2)
 
        # Draw and display the corners
        image = cv2.drawChessboardCorners(image,
                                          CHECKERBOARD,
                                          corners2, ret)
 
    cv2.imshow('img', image)
    cv2.waitKey(0)
 
cv2.destroyAllWindows()
 
h, w = image.shape[:2]
 
 
# Perform camera calibration by
# passing the value of above found out 3D points (threedpoints)
# and its corresponding pixel coordinates of the
# detected corners (twodpoints)
ret, matrix, distortion, r_vecs, t_vecs = cv2.calibrateCamera(
    threedpoints, twodpoints, grayColor.shape[::-1], None, None)
 
 
# Displaying required output
print(" Camera matrix:")
print(matrix)
 
print("\n Distortion coefficient:")
print(distortion)
 
print("\n Rotation Vectors:")
print(r_vecs)
 
print("\n Translation Vectors:")
print(t_vecs)

Aporte:

Producción:

 Camera matrix: 
[[ 36.26378216   0.         125.68539168]
 [  0.          36.76607372 142.49821147]
 [  0.           0.           1.        ]]

 Distortion coefficient: 
[[-1.25491812e-03  9.89269357e-05 -2.89077718e-03  4.52760939e-04
  -3.29964245e-06]]

 Rotation Vectors: 
[array([[-0.05767492],
       [ 0.03549497],
       [ 1.50906953]]), array([[-0.09301982],
       [-0.01034321],
       [ 3.07733805]]), array([[-0.02175332],
       [ 0.05611105],
       [-0.07308161]])]
 
 Translation Vectors: 
[array([[ 4.63047351],
       [-3.74281386],
       [ 1.64238108]]), array([[2.31648737],
       [3.98801521],
       [1.64584622]]), array([[-3.17548808],
       [-3.46022466],
       [ 1.68200157]])]