[Windows] [Python] Kamerakalibrierung des Fischaugenobjektivs mit OpenCV

Vor kurzem war ich fasziniert von der Leichtigkeit, Python-Code zu schreiben, und ich habe ziemlich viel Beispielprogramme in Python geschrieben.

Also das Thema des Titels. Ich kann in meiner zukünftigen Arbeit Fischaugen oder Superweitwinkelobjektive verwenden. Wenn ich also versuche, eine Probe zu machen, Es scheint, dass die Python-Version nicht die cv :: fisheye I / F enthält, die in der C ++ - Version von OpenCV vorhanden ist. .. ..

Ich konnte auf verschiedene Weise nicht aufgeben, also wechselte ich zur normalen Kalibrierung mit Python. Ich habe versucht, das Fischaugenobjektiv zu kalibrieren. (Wenn Sie dies mit der Python-Version tun können, gibt es kein technisches Problem, wenn Sie es ordnungsgemäß mit der C ++ - Version implementieren.

Unten YouTube-Video ↓ https://www.youtube.com/watch?v=WGtZeyfzve4 [](https://www.youtube.com/watch? v = WGtZeyfzve4)

Das? Kannst du das normalerweise tun? Bestätigung erforderlich. Ich habe auch nicht das Gefühl, dass es viele Orte gibt, an denen meine Gefühle abgeschnitten sind. Wahrscheinlich kann ein Weitwinkel von ca. 130 Grad gesichert werden.

Die verwendete Kamera befindet sich übrigens unter ↓ 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

Fügen Sie den folgenden Code ein ↓

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

import numpy as np
import cv2
import Tkinter
import tkMessageBox

square_side_length = 23.0 #Die Größe einer Seite des Quadrats im Schachbrett(mm)
grid_intersection_size = (10, 7) #Anzahl der Gitter im Schachbrett

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','Kalibrierungsdaten(K.csv, d.csv)Willst du lesen'):
    #Kalibrierdaten lesen
    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:
    #Schießbrett schießen
    capture_count = 0
    while(True):
        ret, frame = video_input.read()

        #Zur Erkennung von Schachbrettern in Graustufenbilder konvertieren
        #grayscale_image = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)

        #Erkennt Schachbrettecken
        #found, corner = cv2.findChessboardCorners(grayscale_image, grid_intersection_size)
        found, corner = cv2.findChessboardCorners(frame, grid_intersection_size)

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

            #Finde Chessboard Corners im aktuellen OpenCV()Innerhalb von CornerSubPix()Wird eine beträchtliche Verarbeitung durchgeführt? Bestätigung erforderlich
            #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
            #Informationen zur Erkennung von Schachbrettecken hinzugefügt
            image_points.append(corner)
            object_points.append(pattern_points)
            capture_count += 1
        if c == 110: # N
            if tkMessageBox.askyesno('askyesno','Möchten Sie das Schachbrett-Shooting beenden und die internen Parameter der Kamera ermitteln?'):
                cv2.destroyAllWindows()
                break
        if c == 27: # ESC
            if tkMessageBox.askyesno('askyesno','Möchten Sie das Programm beenden?'):
                video_input.release()
                cv2.destroyAllWindows()
                exit()

    if len(image_points) > 0:
        #Berechnen Sie die internen Parameter der Kamera
        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") #Kameramatrix speichern
        np.savetxt("d.csv", d, delimiter =',',fmt="%0.14f") #Erhaltung des Dehnungskoeffizienten

        camera_mat = K
        dist_coef = d

        #Auswertung durch Reprojektionsfehler
        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) #Ein Wert nahe 0 ist wünschenswert(Nicht zur Beurteilung von Fischaugenlinsen geeignet?)
    else:
        print "findChessboardCorners() not be successful once"

#Bildanzeige zur Verzerrungskorrektur
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()

das ist alles.