camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibration (Operator)

Name

camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibration — Bestimmen aller Kameraparameter durch simultane Ausgleichsrechnung.

Signatur

camera_calibration( : : NX, NY, NZ, NRow, NCol, StartCamParam, NStartPose, EstimateParams : CameraParam, NFinalPose, Errors)

Beschreibung

camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration führt die Kalibrierung einer einzelnen Kamera durch. Dazu werden bekannte 3D-Modellpunkte (mit Koordinaten NXNXNXNXNX, NYNYNYNYNY, NZNZNZNZNZ) ins Bild projiziert und die Summe der Abstandsquadrate zwischen den projizierten 3D-Koordinaten und ihren korrespondierenden Bildpunktkoordinaten (NRowNRowNRowNRowNRow, NColNColNColNColNCol) minimiert.

Als Startwerte für das Ausgleichsverfahren dienen die externen (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose) und internen (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) und Kameraparameter. Dabei wird die 3D-Lage NStartPoseNStartPoseNStartPoseNStartPoseNStartPose mit den initialen Werten für die externen Kameraparameter in der Form erwartet. Dabei steht ccs für das Kamerakoordinatensystem und wcs für das Weltkoordinatensystem (siehe auch Transformationen / Posen und „Solution Guide III-C - 3D Vision“). Bestimmte Kameraparameter können mit EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams ausdrücklich in die Minimierung ein- oder von ihr ausgeschlossen werden. Eine ausführliche Beschreibung der verfügbaren Kameramodelle sowie der dazugehörigen Kameraparameter findet sich in Kalibrierung.

Für eine erfolgreiche Kalibrierung wird mindestens ein Kalibrierobjekt mit genau bekannten metrischen Abmessungen benötigt, z.B. eine HALCON- Kalibrierplatte. Vor dem Aufruf von camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration nehmen Sie eine Serie von Bildern des Kalibrierobjektes in unterschiedlichen Orientierungen auf, so dass das gesamte Blickfeld bzw. Messvolumen ausgefüllt wird. Der Erfolg der Kalibrierung hängt im hohen Maße von der Qualität der Kalibrierbilder ab. Deshalb wird bei der Aufnahme der Kalibrierbilder hohe Sorgfalt empfohlen. Für weitere Informationen sei auf den Abschnitt „Wie nehme ich geeignete Bilder auf?'" in Kalibrierung verwiesen.

Nach erfolgreicher Kalibrierung gibt camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration die optimierten internen (CameraParamCameraParamCameraParamCameraParamcameraParam) und externen (NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose ) Kameraparameter der Kamera zurück. Zusätzlich liefert er die Wurzel des mittleren quadratischen Rückprojektionsfehlers (RMSE) der Optimierung im Parameter ErrorsErrorsErrorsErrorserrors (in Pixel) zurück. Dieser Fehler gibt einen allgemeinen Hinweis darauf, ob die Optimierung erfolgreich war.

Hinweise zur Kalibrierung

Wie extrahiert man die Markenmittelpunkte aus den Bildern?

Wird eine HALCON-Kalibrierplatte verwendet, so können mit Hilfe des Operators find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject für jedes Bild sowohl die Koordinaten der Markenmittelpunkte als auch eine grobe Schätzung der externen Kameraparameter bestimmt werden. Bei HALCON-Kalibrierplatten mit rechteckiger Markenanordnung (siehe gen_caltabgen_caltabGenCaltabGenCaltabGenCaltab) kann alternativ auch eine Kombination der Operatoren find_caltabfind_caltabFindCaltabFindCaltabFindCaltab und find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose verwendet werden. In beiden Fällen können die auf diese Weise erhaltenen Werte dann direkt als Startwerte für die externen Kameraparameter (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose) verwendet werden.

Diejenigen Bilder, auf denen die Suche nach dem Kalibrierkörper (find_caltabfind_caltabFindCaltabFindCaltabFindCaltab) gescheitert ist bzw. für die der Operator find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose oder find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject nicht die Markenpunkte detektieren konnte, sollten nicht in die Eingabeparameter von camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration eingehen.

Wie erhält man die benötigten Startwerte für die Kalibrierung?

Bei Verwendung einer HALCON-Kalibrierplatte sind die Eingabeparameter NXNXNXNXNX, NYNYNYNYNY und NZNZNZNZNZ in der dazugehörigen Beschreibungsdatei gespeichert. Sie können einfach mit caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints ausgelesen werden. Startwerte für die internen Kameraparameter (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) sind in der Regel den Spezifikationen der Kamera zu entnehmen. Für weitere Informationen sei auf das Kapitel Kalibrierung verwiesen. Startwerte für die Lagen des Kalibrierkörpers sowie der Markenmittelpunkte (NRowNRowNRowNRowNRow und NColNColNColNColNCol) können für jedes Bild mit dem Operator find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObject ermittelt werden. Das Tupel NStartPoseNStartPoseNStartPoseNStartPoseNStartPose ergibt sich dann als Konkatenation dieser einzelnen Kameralagen.

Welche der Kameraparameter werden geschätzt?

Mit dem Eingabeparameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams kann angeben werden, welche der gesuchten Kameraparameter tatsächlich bestimmt werden sollen. Üblicherweise ist dieser Wert gleich 'all'"all""all""all""all", d.h. alle 6 externen Kameraparameter (Translation und Rotation) und alle internen Kameraparameter werden in der Ausgleichung geschätzt. Falls die internen Parameter der Kamera bereits bekannt sind (z.B. durch einen früheren Aufruf von camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration), ist es oftmals ausreichend, lediglich die 3D-Lage (Pose) des Weltkoordinatensystems in Kamerakoordinaten zu bestimmen. In diesem Fall kann in EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams der Wert 'pose'"pose""pose""pose""pose" übergeben werden. Um denselben Effekt zu erzielen, kann man als Alternative dem Parameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams auch alle zu bestimmenden Werte übergeben: EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams = ['alpha','beta','gamma','transx','transy','transz']. Andernfalls enthält EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams ein Tupel von Strings, die die Kombination von Parametern, die geschätzt werden soll, enthält. Es ist auch möglich, Parameter die nicht geschätzt werden sollen über ein vorgesetztes '~' Zeichen im String auszuschließen. Die Werte ['pose','~transx']["pose","~transx"]["pose","~transx"]["pose","~transx"]["pose","~transx"] beispielsweise haben denselben Effekt wie ['alpha','beta','gamma','transy','transz']. ['all','~focus']["all","~focus"]["all","~focus"]["all","~focus"]["all","~focus"] zum Beispiel schätzt alle internen und externen Parameter bis auf die Brennweite. Mit Ausnahme von 'all'"all""all""all""all" kann das Präfix '~' jedem Parameterwert vorangestellt werden.

Welche Beschränkungen bestehen bei der Bestimmung der Kameraparameter?

Weiterführende Informationen über generelle Beschränkungen bei der Bestimmung der Kameraparameter finden sich im Abschnitt „Weitere Beschränkungen in Bezug auf spezifische Kameratypen'" des Kapitels Kalibrierung.

Wie sieht die Reihenfolge der einzelnen Parameter aus?

Die Länge des Tupels NStartPoseNStartPoseNStartPoseNStartPoseNStartPose korrespondiert mit der Anzahl der Kalibrierbilder, d.h. werden beispielsweise 15 Aufnahmen eines Kalibrierkörpers verwendet, so ergibt sich die Länge des Tupels NStartPoseNStartPoseNStartPoseNStartPoseNStartPose zu (15 mal je 7 externe Kameraparameter). Die ersten 7 Werte entsprechen daher der Lage des Kalibrierkörpers im 1. Bild, die nächsten 7 derjenigen im 2. Bildes usw.

Die dadurch festgelegte Anzahl der Kalibrierbilder muss auch bei den Tupeln mit den Koordinaten der 3D-Modellmarkenpunkte bzw. der extrahierten 2D-Markenpunkte berücksichtigt werden. Bei einer Anzahl von 15 Kalibrierbildern müssen daher die Tupel NRowNRowNRowNRowNRow und NColNColNColNColNCol 15 mal so viele Werte aufweisen wie die Tupel mit den 3D-Modellmarkenpunkten (NXNXNXNXNX, NYNYNYNYNY und NZNZNZNZNZ). Sind beispielsweise 49 Markenpunkte pro Bild vorhanden, so haben die Tupel NRowNRowNRowNRowNRow und NColNColNColNColNCol jeweils die Länge , die Tupel NXNXNXNXNX, NYNYNYNYNY und NZNZNZNZNZ haben dagegen die Länge 49. Die Reihenfolge der Werte in NRowNRowNRowNRowNRow und NColNColNColNColNCol erfolgt dabei bildweise, d.h. bei 49 Marken korrespondiert der erste 3D-Modellpunkt mit dem 1., 50., 99., 148., 197., 246. etc. extrahierten 2D-Markenpunkt.

Was bedeuten die Ausgabeparameter?

Nach erfolgreicher Kalibrierung sind in den Ausgabeparametern CameraParamCameraParamCameraParamCameraParamcameraParam und NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose die ausgeglichenen Werte der internen und externen Kameraparameter enthalten. Die Länge des Tupels NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose entspricht dann derjenigen von NStartPoseNStartPoseNStartPoseNStartPoseNStartPose.

Die Darstellungstypen von NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose entsprechen dem Darstellungstyp der des ersten Tupels aus NStartPoseNStartPoseNStartPoseNStartPoseNStartPose (siehe create_posecreate_poseCreatePoseCreatePoseCreatePose). Der Darstellungstyp kann jedoch mit convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseType gewandelt werden.

Als weiterer Parameter wird der durchschnittliche Fehler (ErrorsErrorsErrorsErrorserrors) ausgegeben, mit welchem die erzielte Genauigkeit der Kalibrierung abgeschätzt werden kann. Der Fehler (Root-Mean-Square-Fehler der Position) wird in Pixel angegeben. Bei der Kalibrierung von nur einer einzelnen Kamera ist ein Fehler in der Größenordnung von 0.1 Pixel (der typische Detektionsfehler beim Extrahieren der Koordinaten der projizierten Kalibrierkörpermarken) ein Hinweis dafür, dass die Optimierung gut zu den Beobachtungsdaten passt. Wenn der Fehler deutlich über 0.1 Pixel liegt, wurde die Kalibrierung nicht gut ausgeführt. Die Gründe hierfür können z.B. eine schlechte Bildqualität, eine unzureichende Anzahl an Kalibrierbildern oder auch eine fehlerhafte Kalibrierplatte sein.

Muss man einen planaren Kalibrierkörper verwenden?

Es ist nicht nötig, einen planaren Kalibrierkörper zu verwenden. Der Operator camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration ist so ausgelegt, dass er mit den Eingabetupeln NXNXNXNXNX, NYNYNYNYNY, NZNZNZNZNZ, NRowNRowNRowNRowNRow und NColNColNColNColNCol beliebige 3D/2D-Korrespondenzen verarbeiten kann. Der Aufbau der Parameter kann dem Abschnitt „Wie sieht die Reihenfolge der einzelnen Parameter aus?“ entnommen werden.

Es spielt daher prinzipiell keine Rolle, wie man die nötigen 3D-Modellmarkenpunkte und die korrespondierenden 2D-Markenpunkte ermittelt. Somit ist es einerseits möglich, auch einen 3D-Kalibrierkörper zu verwenden. Andererseits kann man auch beliebige markante Punkte (z.B. natürliche Landmarken) verwenden, deren Positionen in der Welt bekannt sind. Falls man dann EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams auf 'pose'"pose""pose""pose""pose" setzt, kann man auf diese Weise mit camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration die Lage eines beliebigen Objektes in Kamerakoordinaten ermitteln! Hierzu sind dann mindestens drei 3D/2D-Korrespondenzen als Eingabe anzugeben. NStartPoseNStartPoseNStartPoseNStartPoseNStartPose kann z.B. direkt über create_posecreate_poseCreatePoseCreatePoseCreatePose generiert werden wie es im dazugehörigen Programmbeispiel gezeigt wird.

Achtung

Das Ergebnis der Kalibrierung hängt von den Startwerten für die internen (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam) und externen (NStartPoseNStartPoseNStartPoseNStartPoseNStartPose) Kameraparameter ab. Anhand der zurückgegebenen durchschnittlichen Fehler (ErrorsErrorsErrorsErrorserrors) kann die Genauigkeit der Kalibrierung abgeschätzt werden. Die Fehler (Abweichungen in x- und y-Koordinate) werden in Pixel angegeben.

Bei der Kalibrierung von Kameras mit Zeilensensor kann der Startwert für den internen Kameraparameter Sy auf den den Wert 0.0 gesetzt werden. In diesem Fall ist es allerdings nicht möglich, die Position des Bildhauptpunktes in y-Richtung zu bestimmen. Im Eingabeparameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams muss aus diesem Grund explizit die y-Koordinate des Bildhauptpunktes ausgeschlossen werden: '~cy'"~cy""~cy""~cy""~cy". Der effektive Abstand des Bildhauptpunktes von der Sensorzeile ist dann immer . Weitere Informationen können dem Abschnitt „Weitere Beschränkungen in Bezug auf spezifische Kameratypen'" in Kalibrierung entnommen werden.

Ausführungsinformationen

Multithreading-Typ: reentrant (läuft parallel zu nicht-exklusiven Operatoren).
Multithreading-Bereich: global (kann von jedem Thread aufgerufen werden).
Wird ohne Parallelisierung verarbeitet.

Parameter

NXNXNXNXNX (input_control) number-array → (real / integer)

Geordnetes Tupel mit allen x-Koordinaten der Kalibriermarken (in Meter).

NYNYNYNYNY (input_control) number-array → (real / integer)

Geordnetes Tupel mit allen y-Koordinaten der Kalibriermarken (in Meter).

Parameteranzahl: NY == NX

NZNZNZNZNZ (input_control) number-array → (real / integer)

Geordnetes Tupel mit allen z-Koordinaten der Kalibriermarken (in Meter).

Parameteranzahl: NZ == NX

NRowNRowNRowNRowNRow (input_control) number-array → (real / integer)

Geordnetes Tupel mit allen Zeilen-Koordinaten der extrahierten Kalibriermarken (in Pixel).

NColNColNColNColNCol (input_control) number-array → (real / integer)

Geordnetes Tupel mit allen Spalten-Koordinaten der extrahierten Kalibriermarken (in Pixel).

Parameteranzahl: NCol == NRow

StartCamParamStartCamParamStartCamParamStartCamParamstartCamParam (input_control) campar → (real / integer / string)

Startwerte für die internen Kameraparameter.

NStartPoseNStartPoseNStartPoseNStartPoseNStartPose (input_control) pose(-array) → (real / integer)

Geordnetes Tupel mit allen Startwerten der externen Kameraparameter.

Parameteranzahl: NStartPose == 7 * NRow / NX

EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParams (input_control) string-array → (string)

Zu schätzenden Kameraparameter.

Defaultwert: 'all' "all" "all" "all" "all"

Werteliste: 'all'"all""all""all""all", 'alpha'"alpha""alpha""alpha""alpha", 'beta'"beta""beta""beta""beta", 'camera'"camera""camera""camera""camera", 'cx'"cx""cx""cx""cx", 'cy'"cy""cy""cy""cy", 'focus'"focus""focus""focus""focus", 'gamma'"gamma""gamma""gamma""gamma", 'image_plane_dist'"image_plane_dist""image_plane_dist""image_plane_dist""image_plane_dist", 'k1'"k1""k1""k1""k1", 'k2'"k2""k2""k2""k2", 'k3'"k3""k3""k3""k3", 'kappa'"kappa""kappa""kappa""kappa", 'magnification'"magnification""magnification""magnification""magnification", 'poly'"poly""poly""poly""poly", 'poly_tan_2'"poly_tan_2""poly_tan_2""poly_tan_2""poly_tan_2", 'pose'"pose""pose""pose""pose", 'sx'"sx""sx""sx""sx", 'sy'"sy""sy""sy""sy", 'tilt'"tilt""tilt""tilt""tilt", 'transx'"transx""transx""transx""transx", 'transy'"transy""transy""transy""transy", 'transz'"transz""transz""transz""transz", 'vx'"vx""vx""vx""vx", 'vy'"vy""vy""vy""vy", 'vz'"vz""vz""vz""vz"

CameraParamCameraParamCameraParamCameraParamcameraParam (output_control) campar → (real / integer / string)

Interne Kameraparameter.

NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPose (output_control) pose(-array) → (real / integer)

Geordnetes Tupel mit allen externen Kameraparametern.

Parameteranzahl: NFinalPose == 7 * NRow / NX

ErrorsErrorsErrorsErrorserrors (output_control) real(-array) → (real)

Durchschnittlicher Fehler in Pixel.

Beispiel (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Beispiel (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Beispiel (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Beispiel (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Beispiel (HDevelop)

* Read calibration images.
read_image(Image1, 'calib/grid_space.cal.k.000')
read_image(Image2, 'calib/grid_space.cal.k.001')
read_image(Image3, 'calib/grid_space.cal.k.002')
*  Find calibration pattern.
find_caltab(Image1, CalPlate1, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image2, CalPlate2, 'caltab_big.descr', 3, 112, 5)
find_caltab(Image3, CalPlate3, 'caltab_big.descr', 3, 112, 5)
*  Find calibration marks and start poses.
StartCamPar := ['area_scan_division', 0.008, 0.0, 0.000011, 0.000011, \
                384, 288, 768, 576]
find_marks_and_pose(Image1, CalPlate1, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord1, CCoord1, \
                    StartPose1)
find_marks_and_pose(Image2, CalPlate2, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord2, CCoord2, \
                    StartPose2)
find_marks_and_pose(Image3, CalPlate3, 'caltab_big.descr', StartCamPar, \
                    128, 10, 18, 0.9, 15.0, 100.0, RCoord3, CCoord3, \
                    StartPose3)
*  Read 3D positions of calibration marks.
caltab_points('caltab_big.descr', NX, NY, NZ)
*  Camera calibration.
camera_calibration(NX, NY, NZ, [RCoord1, RCoord2, RCoord3], \
                   [CCoord1, CCoord2, CCoord3], StartCamPar, \
                   [StartPose1, StartPose2, StartPose3], 'all', \
                   CameraParam, NFinalPose, Errors)
*  Write internal camera parameters to file.
write_cam_par(CameraParam, 'campar.dat')

Ergebnis

Sind die Parameterwerte korrekt und konnten die gesuchten Kameraparameter durch das Bündelausgleichsverfahren bestimmt werden, dann liefert camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibration den Wert 2 (H_MSG_TRUE). Gegebenenfalls wird eine Fehlerbehandlung durchgeführt

Vorgänger

find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints, read_cam_parread_cam_parReadCamParReadCamParReadCamPar

Nachfolger

write_posewrite_poseWritePoseWritePoseWritePose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3d, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltab

Alternativen

calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCameras

Siehe auch

find_caltabfind_caltabFindCaltabFindCaltabFindCaltab, find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPose, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltab, write_cam_parwrite_cam_parWriteCamParWriteCamParWriteCamPar, read_cam_parread_cam_parReadCamParReadCamParReadCamPar, create_posecreate_poseCreatePoseCreatePoseCreatePose, convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseType, write_posewrite_poseWritePoseWritePoseWritePose, read_poseread_poseReadPoseReadPoseReadPose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3d, hom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPoseHomMat3dToPose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPoints, gen_caltabgen_caltabGenCaltabGenCaltabGenCaltab, calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCameras

Modul

Calibration

Operatoren