[Windows] [Python] Calibrage de la caméra de l'objectif fisheye avec OpenCV

Récemment, j'ai été fasciné par la facilité d'écriture du code Python, et j'ai beaucoup écrit des exemples de programmes en Python.

Donc, le sujet du titre. Je peux utiliser des yeux de poisson ou des objectifs super grand angle pour mes futurs travaux, donc si j'essaie de faire un échantillon d'essai, Il semble que la version Python n'ait pas le cv :: fisheye I / F qui existe dans la version C ++ d'OpenCV. .. ..

Je ne pouvais pas abandonner de différentes manières, alors j'ai pris le tour de l'étalonnage normal avec Python. J'ai essayé de calibrer l'objectif fisheye. (Si vous pouvez le faire avec la version Python, il n'y aura pas de problème technique si vous l'implémentez correctement avec la version C ++.

Ci-dessous, vidéo YouTube ↓ https://www.youtube.com/watch?v=WGtZeyfzve4 [](https://www.youtube.com/watch? v = WGtZeyfzve4)

cette? Est-ce quelque chose que vous pouvez faire normalement? Confirmation requise. De plus, je n'ai pas l'impression qu'il y a beaucoup d'endroits où mes sentiments sont coupés. Probablement un grand angle d'environ 130 degrés peut être obtenu.

Au fait, la caméra utilisée est en dessous ↓ https://www.amazon.co.jp/ELP-USB2-0-Ominivison-OV2710-%E5%BA%A6%E3%83%A1%E3%82%AC%E3%83%94%E3%82%AF%E3%82%BB%E3%83%AB%E9%AD%9A%E7%9C%BC%E3%83%AC%E3%83%B3%E3%82%BA/dp/B017R02JLI

Collez le code ci-dessous ↓

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import numpy as np
import cv2
import Tkinter
import tkMessageBox

square_side_length = 23.0 #La taille d'un côté du carré dans l'échiquier(mm)
grid_intersection_size = (10, 7) #Nombre de grilles dans l'échiquier

pattern_points = np.zeros( (np.prod(grid_intersection_size), 3), np.float32 )
pattern_points[:,:2] = np.indices(grid_intersection_size).T.reshape(-1, 2)
pattern_points *= square_side_length
object_points = []
image_points = []

root = Tkinter.Tk()
root.withdraw()

video_input = cv2.VideoCapture(1)
if (video_input.isOpened() == False):
    exit()

camera_mat, dist_coef = [], []

if tkMessageBox.askyesno('askyesno','Données d'étalonnage(K.csv, d.csv)Voulez-vous lire?'):
    #Lecture des données d'étalonnage
    camera_mat = np.loadtxt('K.csv', delimiter=',')
    dist_coef = np.loadtxt('d.csv', delimiter=',')
    print "K = \n", camera_mat
    print "d = ", dist_coef.ravel()
else:
    #Échiquier de tir
    capture_count = 0
    while(True):
        ret, frame = video_input.read()

        #Convertir en image en niveaux de gris pour la détection de l'échiquier
        #grayscale_image = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)

        #Détecte les coins de l'échiquier
        #found, corner = cv2.findChessboardCorners(grayscale_image, grid_intersection_size)
        found, corner = cv2.findChessboardCorners(frame, grid_intersection_size)

        if found == True:
            print 'findChessboardCorners : True'

            #Trouver des coins d'échecs dans l'OpenCV actuel()À l'intérieur, cornerSubPix()Un traitement considérable est-il en cours? Confirmation requise
            #term = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1)
            #cv2.cornerSubPix(grayscale_image, corner, (5,5), (-1,-1), term)
            #cv2.drawChessboardCorners(grayscale_image, grid_intersection_size, corner, found)

            cv2.drawChessboardCorners(frame, grid_intersection_size, corner, found)
        if found == False:
            print 'findChessboardCorners : False'

        cv2.putText(frame, "Enter:Capture Chessboard(" + str(capture_count) + ")", (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)
        cv2.putText(frame, "N    :Completes Calibration Photographing", (100, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)
        cv2.putText(frame, "ESC  :terminate program", (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)
        #cv2.putText(grayscale_image, "Enter:Capture Chessboard(" + str(capture_count) + ")", (100, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)
        #cv2.putText(grayscale_image, "ESC  :Completes Calibration Photographing.", (100, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)
        cv2.imshow('original', frame)
        #cv2.imshow('findChessboardCorners', grayscale_image)

        c = cv2.waitKey(50) & 0xFF
        if c == 13 and found == True: # Enter
            #Ajout d'informations sur la détection des coins de l'échiquier
            image_points.append(corner)
            object_points.append(pattern_points)
            capture_count += 1
        if c == 110: # N
            if tkMessageBox.askyesno('askyesno','Voulez-vous terminer le tournage de l'échiquier et trouver les paramètres internes de la caméra?'):
                cv2.destroyAllWindows()
                break
        if c == 27: # ESC
            if tkMessageBox.askyesno('askyesno','Voulez-vous quitter le programme?'):
                video_input.release()
                cv2.destroyAllWindows()
                exit()

    if len(image_points) > 0:
        #Calculer les paramètres internes de la caméra
        print 'calibrateCamera() start'
        rms, K, d, r, t = cv2.calibrateCamera(object_points,image_points,(frame.shape[1],frame.shape[0]),None,None)
        print "RMS = ", rms
        print "K = \n", K
        print "d = ", d.ravel()
        np.savetxt("K.csv", K, delimiter =',',fmt="%0.14f") #Enregistrer la matrice de la caméra
        np.savetxt("d.csv", d, delimiter =',',fmt="%0.14f") #Préservation du coefficient de déformation

        camera_mat = K
        dist_coef = d

        #Évaluation par erreur de reprojection
        mean_error = 0
        for i in xrange(len(object_points)):
            image_points2, _ = cv2.projectPoints(object_points[i], r[i], t[i], camera_mat, dist_coef)
            error = cv2.norm(image_points[i], image_points2, cv2.NORM_L2) / len(image_points2)
            mean_error += error
        print "total error: ", mean_error/len(object_points) #Une valeur proche de 0 est souhaitable(Ne convient pas à l'évaluation des objectifs fisheye?)
    else:
        print "findChessboardCorners() not be successful once"

#Affichage de l'image de correction de la distorsion
if camera_mat != []:
    while(True):
        ret, frame = video_input.read()
        undistort_image = cv2.undistort(frame, camera_mat, dist_coef)

        cv2.imshow('original', frame)
        cv2.imshow('undistort', undistort_image)
        c = cv2.waitKey(50) & 0xFF
        if c==27: # ESC
            break

video_input.release()
cv2.destroyAllWindows()

c'est tout.