camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibrationcamera_calibration (Operator)

Name

camera_calibrationT_camera_calibrationCameraCalibrationCameraCalibrationcamera_calibration — Bestimmen aller Kameraparameter durch simultane Ausgleichsrechnung.

Signatur

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

Beschreibung

camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration führt die Kalibrierung einer einzelnen Kamera durch. Dazu werden bekannte 3D-Modellpunkte (mit Koordinaten NXNXNXNXNXnx, NYNYNYNYNYny, NZNZNZNZNZnz) ins Bild projiziert und die Summe der Abstandsquadrate zwischen den projizierten 3D-Koordinaten und ihren korrespondierenden Bildpunktkoordinaten (NRowNRowNRowNRowNRownrow, NColNColNColNColNColncol) minimiert.

Als Startwerte für das Ausgleichsverfahren dienen die externen (NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose) und internen (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParamstart_cam_param) und Kameraparameter. Dabei wird die 3D-Lage NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose 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 EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params 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_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration 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_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration die optimierten internen (CameraParamCameraParamCameraParamCameraParamcameraParamcamera_param) und externen (NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPosenfinal_pose ) Kameraparameter der Kamera zurück. Zusätzlich liefert er die Wurzel des mittleren quadratischen Rückprojektionsfehlers (RMSE) der Optimierung im Parameter ErrorsErrorsErrorsErrorserrorserrors (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_objectFindCalibObjectFindCalibObjectFindCalibObjectfind_calib_object 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_caltabGenCaltabGenCaltabGenCaltabgen_caltab) kann alternativ auch eine Kombination der Operatoren find_caltabfind_caltabFindCaltabFindCaltabFindCaltabfind_caltab und find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPosefind_marks_and_pose verwendet werden. In beiden Fällen können die auf diese Weise erhaltenen Werte dann direkt als Startwerte für die externen Kameraparameter (NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose) verwendet werden.

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

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

Bei Verwendung einer HALCON-Kalibrierplatte sind die Eingabeparameter NXNXNXNXNXnx, NYNYNYNYNYny und NZNZNZNZNZnz in der dazugehörigen Beschreibungsdatei gespeichert. Sie können einfach mit caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPointscaltab_points ausgelesen werden. Startwerte für die internen Kameraparameter (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParamstart_cam_param) 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 (NRowNRowNRowNRowNRownrow und NColNColNColNColNColncol) können für jedes Bild mit dem Operator find_calib_objectfind_calib_objectFindCalibObjectFindCalibObjectFindCalibObjectfind_calib_object ermittelt werden. Das Tupel NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose ergibt sich dann als Konkatenation dieser einzelnen Kameralagen.

Welche der Kameraparameter werden geschätzt?

Mit dem Eingabeparameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params kann angeben werden, welche der gesuchten Kameraparameter tatsächlich bestimmt werden sollen. Üblicherweise ist dieser Wert gleich 'all'"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_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration), ist es oftmals ausreichend, lediglich die 3D-Lage (Pose) des Weltkoordinatensystems in Kamerakoordinaten zu bestimmen. In diesem Fall kann in EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params der Wert 'pose'"pose""pose""pose""pose""pose" übergeben werden. Um denselben Effekt zu erzielen, kann man als Alternative dem Parameter EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params auch alle zu bestimmenden Werte übergeben: EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params = ['alpha','beta','gamma','transx','transy','transz']. Andernfalls enthält EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params 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"]["pose","~transx"] beispielsweise haben denselben Effekt wie ['alpha','beta','gamma','transy','transz']. ['all','~focus']["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""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 NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose korrespondiert mit der Anzahl der Kalibrierbilder, d.h. werden beispielsweise 15 Aufnahmen eines Kalibrierkörpers verwendet, so ergibt sich die Länge des Tupels NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose 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 NRowNRowNRowNRowNRownrow und NColNColNColNColNColncol 15 mal so viele Werte aufweisen wie die Tupel mit den 3D-Modellmarkenpunkten (NXNXNXNXNXnx, NYNYNYNYNYny und NZNZNZNZNZnz). Sind beispielsweise 49 Markenpunkte pro Bild vorhanden, so haben die Tupel NRowNRowNRowNRowNRownrow und NColNColNColNColNColncol jeweils die Länge , die Tupel NXNXNXNXNXnx, NYNYNYNYNYny und NZNZNZNZNZnz haben dagegen die Länge 49. Die Reihenfolge der Werte in NRowNRowNRowNRowNRownrow und NColNColNColNColNColncol 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 CameraParamCameraParamCameraParamCameraParamcameraParamcamera_param und NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPosenfinal_pose die ausgeglichenen Werte der internen und externen Kameraparameter enthalten. Die Länge des Tupels NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPosenfinal_pose entspricht dann derjenigen von NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose.

Die Darstellungstypen von NFinalPoseNFinalPoseNFinalPoseNFinalPoseNFinalPosenfinal_pose entsprechen dem Darstellungstyp der des ersten Tupels aus NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose (siehe create_posecreate_poseCreatePoseCreatePoseCreatePosecreate_pose). Der Darstellungstyp kann jedoch mit convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseTypeconvert_pose_type gewandelt werden.

Als weiterer Parameter wird der durchschnittliche Fehler (ErrorsErrorsErrorsErrorserrorserrors) 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_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration ist so ausgelegt, dass er mit den Eingabetupeln NXNXNXNXNXnx, NYNYNYNYNYny, NZNZNZNZNZnz, NRowNRowNRowNRowNRownrow und NColNColNColNColNColncol 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 EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params auf 'pose'"pose""pose""pose""pose""pose" setzt, kann man auf diese Weise mit camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration die Lage eines beliebigen Objektes in Kamerakoordinaten ermitteln! Hierzu sind dann mindestens drei 3D/2D-Korrespondenzen als Eingabe anzugeben. NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose kann z.B. direkt über create_posecreate_poseCreatePoseCreatePoseCreatePosecreate_pose generiert werden wie es im dazugehörigen Programmbeispiel gezeigt wird.

Achtung

Das Ergebnis der Kalibrierung hängt von den Startwerten für die internen (StartCamParamStartCamParamStartCamParamStartCamParamstartCamParamstart_cam_param) und externen (NStartPoseNStartPoseNStartPoseNStartPoseNStartPosenstart_pose) Kameraparameter ab. Anhand der zurückgegebenen durchschnittlichen Fehler (ErrorsErrorsErrorsErrorserrorserrors) 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 EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params muss aus diesem Grund explizit die y-Koordinate des Bildhauptpunktes ausgeschlossen werden: '~cy'"~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

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

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

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

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

Parameteranzahl: NY == NX

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

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

Parameteranzahl: NZ == NX

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

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

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

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

Parameteranzahl: NCol == NRow

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

Startwerte für die internen Kameraparameter.

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

Geordnetes Tupel mit allen Startwerten der externen Kameraparameter.

Parameteranzahl: NStartPose == 7 * NRow / NX

EstimateParamsEstimateParamsEstimateParamsEstimateParamsestimateParamsestimate_params (input_control) string-array → (string)

Zu schätzenden Kameraparameter.

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

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

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

Interne Kameraparameter.

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

Geordnetes Tupel mit allen externen Kameraparametern.

Parameteranzahl: NFinalPose == 7 * NRow / NX

ErrorsErrorsErrorsErrorserrorserrors (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 (C++)

HTuple StartCamPar, NX, NY, NZ;
HTuple RCoord1, CCoord1, StartPose1;
HTuple RCoord2, CCoord2, StartPose2;
HTuple RCoord3, CCoord3, StartPose3;
HTuple StartPoses, RCoords, CCoords;
HTuple CameraParam, NFinalPose, Errors;
// Read calibration images.
HImage Image1("calib/grid_space.cal.k.000");
HImage Image2("calib/grid_space.cal.k.001");
HImage Image3("calib/grid_space.cal.k.002");
// Find calibration pattern.
HRegion CalPlate1 = Image1.FindCaltab("caltab_big.descr", 3, 112, 5);
HRegion CalPlate2 = Image2.FindCaltab("caltab_big.descr", 3, 112, 5);
HRegion CalPlate3 = Image3.FindCaltab("caltab_big.descr", 3, 112, 5);
// Find calibration marks and start poses.
StartCamPar[8] = 576;                  // ImageHeight
StartCamPar[7] = 768;                  // ImageWidth
StartCamPar[6] = 288;                  // Cy
StartCamPar[5] = 384;                  // Cx
StartCamPar[4] = 0.000011;             // Sy
StartCamPar[3] = 0.000011;             // Sx
StartCamPar[2] = 0.0;                  // Kappa
StartCamPar[1] = 0.008;                // Focus
StartCamPar[0] = "area_scan_division"; // CameraType
RCoord1 = Image1.FindMarksAndPose(CalPlate1, "caltab_big.descr", StartCamPar,
                                  128, 10, &CCoord1, &StartPose1);
RCoord2 = Image2.FindMarksAndPose(CalPlate2, "caltab_big.descr", StartCamPar,
                                  128, 10, &CCoord2, &StartPose2);
RCoord3 = Image3.FindMarksAndPose(CalPlate3, "caltab_big.descr", StartCamPar,
                                  128, 10, &CCoord3, &StartPose3);
// Read 3D positions of calibration marks.
caltab_points("caltab_big.descr", &NX, &NY, &NZ);
// Camera calibration.
StartPoses = (StartPose1.Append(StartPose2)).Append(StartPose3);
RCoords = (RCoord1.Append(RCoord2)).Append(RCoord3);
CCoords = (CCoord1.Append(CCoord2)).Append(CCoord3);
camera_calibration(NX, NY, NZ, RCoords, CCoords, StartCamPar, StartPoses,
                   "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_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration den Wert TRUE. Gegebenenfalls wird eine Fehlerbehandlung durchgeführt

Vorgänger

find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPosefind_marks_and_pose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPointscaltab_points, read_cam_parread_cam_parReadCamParReadCamParReadCamParread_cam_par

Nachfolger

write_posewrite_poseWritePoseWritePoseWritePosewrite_pose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3dpose_to_hom_mat3d, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltabdisp_caltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltabsim_caltab

Alternativen

calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCamerascalibrate_cameras

Siehe auch

find_caltabfind_caltabFindCaltabFindCaltabFindCaltabfind_caltab, find_marks_and_posefind_marks_and_poseFindMarksAndPoseFindMarksAndPoseFindMarksAndPosefind_marks_and_pose, disp_caltabdisp_caltabDispCaltabDispCaltabDispCaltabdisp_caltab, sim_caltabsim_caltabSimCaltabSimCaltabSimCaltabsim_caltab, write_cam_parwrite_cam_parWriteCamParWriteCamParWriteCamParwrite_cam_par, read_cam_parread_cam_parReadCamParReadCamParReadCamParread_cam_par, create_posecreate_poseCreatePoseCreatePoseCreatePosecreate_pose, convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseTypeconvert_pose_type, write_posewrite_poseWritePoseWritePoseWritePosewrite_pose, read_poseread_poseReadPoseReadPoseReadPoseread_pose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3dpose_to_hom_mat3d, hom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPoseHomMat3dToPosehom_mat3d_to_pose, caltab_pointscaltab_pointsCaltabPointsCaltabPointsCaltabPointscaltab_points, gen_caltabgen_caltabGenCaltabGenCaltabGenCaltabgen_caltab, calibrate_camerascalibrate_camerasCalibrateCamerasCalibrateCamerasCalibrateCamerascalibrate_cameras

Modul

Calibration

Operatoren