binocular_distanceT_binocular_distanceBinocularDistancebinocular_distanceBinocularDistanceBinocularDistance (Operator)

Name

binocular_distanceT_binocular_distanceBinocularDistancebinocular_distanceBinocularDistanceBinocularDistance — Berechnet das Distanzbild für ein rektifiziertes Bildpaar mit Hilfe von Korrelationsmethoden.

Signatur

binocular_distance(Image1, Image2 : Distance, Score : CamParamRect1, CamParamRect2, RelPoseRect, Method, MaskWidth, MaskHeight, TextureThresh, MinDisparity, MaxDisparity, NumLevels, ScoreThresh, Filter, SubDistance : )

Beschreibung

binocular_distancebinocular_distanceBinocularDistancebinocular_distanceBinocularDistanceBinocularDistance berechnet das Distanzbild für ein rektifiziertes Bildpaar mit Hilfe von Korrelationsmethoden. Der Operator berechnet zunächst die Disparitäten zwischen den zwei rektifizierten Bildern Image1Image1Image1Image1Image1image1 und Image2Image2Image2Image2Image2image2 ähnlich wie in binocular_disparitybinocular_disparityBinocularDisparitybinocular_disparityBinocularDisparityBinocularDisparity. Die resultierenden Disparitätswerte werden dann wie in disparity_to_distancedisparity_to_distanceDisparityToDistancedisparity_to_distanceDisparityToDistanceDisparityToDistance in Distanzwerte der korrespondierenden 3D Weltpunkte zu dem rektifiziertem Stereo-Kamerasystem transformiert. Die Distanzen werden in dem einkanaligem Bild DistanceDistanceDistanceDistanceDistancedistance zurückgegeben, in dem jeder Grauwert den Abstand des jeweiligen 3D Weltpunktes zu dem Stereo-Kamerasystem repräsentiert.

Der Algorithmus benötigt ein Referenzbild Image1Image1Image1Image1Image1image1 und ein Suchbild Image2Image2Image2Image2Image2image2, welche entzerrt sein müssen, d.h. korrespondierende Epipolarlinien liegen parallel und haben identische Bildzeilenkoordinaten (r1=r2). Falls diese Annahme nicht zutrifft, können die Bilder durch die Operatoren calibrate_camerascalibrate_camerasCalibrateCamerascalibrate_camerasCalibrateCamerasCalibrateCameras, gen_binocular_rectification_mapgen_binocular_rectification_mapGenBinocularRectificationMapgen_binocular_rectification_mapGenBinocularRectificationMapGenBinocularRectificationMap und map_imagemap_imageMapImagemap_imageMapImageMapImage entzerrt werden. Ausgehend von einem Pixel im Referenzbild Image1Image1Image1Image1Image1image1 kann dann das zugehörige Pixel in Image2Image2Image2Image2Image2image2 durch die Suche entlang der korrespondierenden Zeile in Image2Image2Image2Image2Image2image2 gefunden werden. Eine Übereinstimmung wird gefunden, indem jeweils eine lokale Nachbarschaft um das entsprechende Pixel innerhalb eines Fensters der Größe MaskWidthMaskWidthMaskWidthMaskWidthMaskWidthmaskWidth und MaskHeightMaskHeightMaskHeightMaskHeightMaskHeightmaskHeight in beiden Bildern miteinander verglichen wird. Für jedes definierte Referenzpixel wird die Pixelkorrespondenz in einen Distanzwert des 3D Punktes transformiert, der durch den Schnittpunkt der Sichtstrahlen durch beide korrespondierenden Pixel definiert ist.

Für diese Transformation werden die entzerrten internen Parameter für die Kamera 1 in CamParamRect1CamParamRect1CamParamRect1CamParamRect1CamParamRect1camParamRect1 und für die Kamera 2 in CamParamRect2CamParamRect2CamParamRect2CamParamRect2CamParamRect2camParamRect2 als auch die relativen externen Kameraparameter RelPoseRectRelPoseRectRelPoseRectRelPoseRectRelPoseRectrelPoseRect benötigt, welche die relative Lage der beiden Kamerasysteme zueinander beschreibt und eine Punkttransformation von dem entzerrten Kamerasystem 2 in das entzerrte Kamerasystem 1 definiert. Die Werte für diese Parameter erhält man beispielsweise von den Operatoren calibrate_camerascalibrate_camerasCalibrateCamerascalibrate_camerasCalibrateCamerasCalibrateCameras und gen_binocular_rectification_mapgen_binocular_rectification_mapGenBinocularRectificationMapgen_binocular_rectification_mapGenBinocularRectificationMapGenBinocularRectificationMap. Ein Qualitätsmaß für jeden Distanzwert wird in ScoreScoreScoreScoreScorescore zurückgegeben, welches jeweils das beste Ergebnis der Korrelationsfunktion S für einen Referenzpixel enthält. Für die Korrelation werden die Grauwerte der originalen, nicht vorverarbeiteten Eingabebilder genutzt.

Die verwendete Korrelationsfunktion wird durch den Parameter MethodMethodMethodMethodMethodmethod bestimmt, welcher drei Arten unterscheidet:

'sad'"sad""sad""sad""sad""sad": Summed Absolute Differences

       S(r1,c1,d) := SUM(|g1(r1',c1')-g2(r1',c1'+d)|), 0=<=S<=255,

'ssd'"ssd""ssd""ssd""ssd""ssd": Summed Squared Differences

       S(r1,c1,d) := SUM((g1(r1',c1')-g2(r1',c1'+d))²), 0<=S<=65025,

'nnc'"nnc""nnc""nnc""nnc""nnc": Normalized Cross Correlation

       S(r1,c1,d) :=
         SUM(g1(r1',c1')-gm1(r1,c1))*(g2(r1',c1'+d)-gm2(r1,c1+d)))/
         SQRT(SUM((g1(r1',c1')-gm1(r1,c1))²)*
              SUM((g2(r1',c1+d)-gm2(r1,c1+d))²)),
       -1.0<=S<=1.0,

wobei

r1, c1, r2, c2: Zeilen- und Spaltenkoordinaten der korrespondierenden Pixel der beiden Eingabebilder,

g1, g2: Grauwerte der nicht vorverarbeiteten Eingabebilder,

N=(2m+1)(2n+1): Größe des Korrelationsfensters,

SUM(x): mittlerer Grauwert innerhalb eines Korrelationsfensters der Breite 2m+1 und Höhe 2n+1.

Die Methoden 'sad'"sad""sad""sad""sad""sad" und 'ssd'"ssd""ssd""ssd""ssd""ssd" vergleichen direkt die Grauwerte der Pixel innerhalb des Grauwertfensters, wohingegen 'ncc'"ncc""ncc""ncc""ncc""ncc" den mittleren Grauwert und seine Varianz innerhalb des Grauwertfensters ausgleicht. Wenn zwei Bilder in ihrer Helligkeit und ihrem Kontrast unterschiedlich sind, ist daher 'ncc'"ncc""ncc""ncc""ncc""ncc" vorzuziehen. Ansonsten sind 'sad'"sad""sad""sad""sad""sad" und 'ssd'"ssd""ssd""ssd""ssd""ssd" vorzuziehen, da sie aufgrund einfacherer interner Berechnungen schneller sind.

Es muss darauf geachtet werden, dass die Güte der Korrelation für steigende S in den Methoden 'sad'"sad""sad""sad""sad""sad" und 'ssd'"ssd""ssd""ssd""ssd""ssd" fällt (die beste Güte ist 0), während sie in der Methode 'ncc'"ncc""ncc""ncc""ncc""ncc" steigt (die beste Güte ist 1.0).

Die Größe des Korrelationsfensters, welche durch 2m+1 und 2n+1 in obigen Gleichungen referenziert wird, muss ungeradzahlig sein und kann durch die Parameter MaskWidthMaskWidthMaskWidthMaskWidthMaskWidthmaskWidth und MaskHeightMaskHeightMaskHeightMaskHeightMaskHeightmaskHeight festgelegt werden. Der Suchraum wird durch den minimalen und maximalen Disparitätswert MinDisparityMinDisparityMinDisparityMinDisparityMinDisparityminDisparity und MaxDisparityMaxDisparityMaxDisparityMaxDisparityMaxDisparitymaxDisparity festgelegt. Da Grauwerte nicht außerhalb des Bildrandes definiert sind wird die Bildregion des DistanceDistanceDistanceDistanceDistancedistance und ScoreScoreScoreScoreScorescore Bildes am unteren und oberen Bildrand um (MaskHeightMaskHeightMaskHeightMaskHeightMaskHeightmaskHeight-1)/2 sowie am linken und rechten Rand um (MaskWidthMaskWidthMaskWidthMaskWidthMaskWidthmaskWidth-1)/2 beschnitten. Aus dem gleichen Grund wird der maximale Suchraum am linken und rechten Bildrand begrenzt.

Da die Korrelationsverfahren in schwach texturierten Bildregionen im hohen Maße ungenau werden, kann die kleinste, innerhalb eines Korrelationsfensters erlaubte Grauwertstreuung mit Hilfe des Parameters TextureThreshTextureThreshTextureThreshTextureThreshTextureThreshtextureThresh definiert werden. Dieser Schwellwert wird auf beiden Eingabebildern Image1Image1Image1Image1Image1image1 und Image2Image2Image2Image2Image2image2 angewendet. Zusätzlich garantiert ScoreThreshScoreThreshScoreThreshScoreThreshScoreThreshscoreThresh eine Mindestgüte der verwendeten Korrelationsfunktion und legt für die Methoden 'sad'"sad""sad""sad""sad""sad" und 'ssd'"ssd""ssd""ssd""ssd""ssd" den größten, bzw. für 'ncc'"ncc""ncc""ncc""ncc""ncc" den kleinsten zulässigen Korrelationswert fest. Wird ferner FilterFilterFilterFilterFilterfilter auf 'left_right_check'"left_right_check""left_right_check""left_right_check""left_right_check""left_right_check" gesetzt, werden nur noch diejenigen Disparitätswerte zurückgegeben, die übereinstimmend bei einer Suche eines Referenzmusters von Image1Image1Image1Image1Image1image1 in Image2Image2Image2Image2Image2image2 als auch von Image2Image2Image2Image2Image2image2 in Image1Image1Image1Image1Image1image1 gefunden werden. Der Wert 'none'"none""none""none""none""none" hingegen schaltet dieses Verhalten aus.

Die Anzahl der Pyramidenstufen, welche verwendet werden um das Zeitverhalten von binocular_distancebinocular_distanceBinocularDistancebinocular_distanceBinocularDistanceBinocularDistance zu verbessern, wird durch den Parameter NumLevelsNumLevelsNumLevelsNumLevelsNumLevelsnumLevels bestimmt. Einem grob-zu-fein Schema folgend werden die Disparitätsbilder der höheren Stufen berechnet und in rechteckige Bildteile von ähnlicher Disparität unterteilt um den Suchbereich auf der nächst niedrigeren Stufe für diesen Bildausschnitt einzuschränken. TextureThreshTextureThreshTextureThreshTextureThreshTextureThreshtextureThresh und ScoreThreshScoreThreshScoreThreshScoreThreshScoreThreshscoreThresh werden auf jeder Stufe angewendet, so dass die mit DistanceDistanceDistanceDistanceDistancedistance und ScoreScoreScoreScoreScorescore zurückgegebene Bildregion als die Schnittmenge der Bildregionen auf jeder einzelnen Stufe definiert ist. Im Allgemeinen lohnt sich das Verwenden von Pyramidenstrukturen um so mehr, je mehr das Distanzbild in homogene Bereiche unterteilt werden kann und je größer der Disparitätsbereich definiert werden muss. Auf der anderen Seite können zu hohe Pyramidenstufen durch ihre grobe Auflösung wichtige Texturinformationen verlieren, so dass falsche Distanzwerte zurückgegeben werden können.

Der Wert 'interpolation'"interpolation""interpolation""interpolation""interpolation""interpolation" für den Parameter SubDistanceSubDistanceSubDistanceSubDistanceSubDistancesubDistance schließlich erhöht die Genauigkeit und Unterteilung der Distanzwerte. Das Verhalten wird ausgeschaltet indem der Parameter auf 'none'"none""none""none""none""none" gesetzt wird.

Achtung

Bei der Verwendung von telezentrischen Kameras bezieht sich die Distanz DistanceDistanceDistanceDistanceDistancedistance nicht auf die Entfernung eines Punktes zum Projektionszentrum einer Kamera. Die Entfernung wird zu der Ebene gemessen, die durch die y-Achse beider Kameras und der Basis (siehe gen_binocular_rectification_mapgen_binocular_rectification_mapGenBinocularRectificationMapgen_binocular_rectification_mapGenBinocularRectificationMapGenBinocularRectificationMap) definiert ist.

Parallelisierung

Multithreading-Typ: reentrant (läuft parallel zu nicht-exklusiven Operatoren).
Multithreading-Bereich: global (kann von jedem Thread aufgerufen werden).
Automatisch parallelisiert auf interner Datenebene.

Parameter

Image1Image1Image1Image1Image1image1 (input_object) singlechannelimage → object (byte)

Rektifiziertes Bild von Kamera 1.

Image2Image2Image2Image2Image2image2 (input_object) singlechannelimage → object (byte)

Rektifiziertes Bild von Kamera 2.

DistanceDistanceDistanceDistanceDistancedistance (output_object) singlechannelimage → object (real)

Distanzbild.

ScoreScoreScoreScoreScorescore (output_object) singlechannelimage → object (real)

Maß für die Zuverlässigkeit eines Disparitätwertes.

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

Interne Kameraparameter der rektifizierten Kamera 1.

Parameteranzahl: CamParamRect1 == 8 || CamParamRect1 == 12

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

Interne Kameraparameter der rektifizierten Kamera 2.

Parameteranzahl: CamParamRect2 == 8 || CamParamRect2 == 12

RelPoseRectRelPoseRectRelPoseRectRelPoseRectRelPoseRectrelPoseRect (input_control) pose → (real / integer)

Punkttransformation von entzerrter Kamera 2 zu entzerrter Kamera 1.

Parameteranzahl: 7

MethodMethodMethodMethodMethodmethod (input_control) string → (string)

Korrespondenzverfahren.

Defaultwert: 'ncc' "ncc" "ncc" "ncc" "ncc" "ncc"

Werteliste: 'ncc'"ncc""ncc""ncc""ncc""ncc", 'sad'"sad""sad""sad""sad""sad", 'ssd'"ssd""ssd""ssd""ssd""ssd"

MaskWidthMaskWidthMaskWidthMaskWidthMaskWidthmaskWidth (input_control) integer → (integer)

Breite des Korrelationsfensters.

Defaultwert: 11

Wertevorschläge: 5, 7, 9, 11, 21

Restriktion: 3 <= MaskWidth && odd(MaskWidth)

MaskHeightMaskHeightMaskHeightMaskHeightMaskHeightmaskHeight (input_control) integer → (integer)

Höhe des Korrelationsfensters.

Defaultwert: 11

Wertevorschläge: 5, 7, 9, 11, 21

Restriktion: 3 <= MaskHeight && odd(MaskHeight)

TextureThreshTextureThreshTextureThreshTextureThreshTextureThreshtextureThresh (input_control) real → (real / integer)

Schwellwert der Grauwertvarianz.

Defaultwert: 0.0

Wertevorschläge: 0.0, 2.0, 5.0, 10.0

Restriktion: 0.0 <= TextureThresh

MinDisparityMinDisparityMinDisparityMinDisparityMinDisparityminDisparity (input_control) integer → (integer)

Minimale erwartete Disparität.

Defaultwert: 0

Typischer Wertebereich: -32768 ≤ MinDisparity MinDisparity MinDisparity MinDisparity MinDisparity minDisparity ≤ 32767

MaxDisparityMaxDisparityMaxDisparityMaxDisparityMaxDisparitymaxDisparity (input_control) integer → (integer)

Maximale erwartete Disparität.

Defaultwert: 30

Typischer Wertebereich: -32768 ≤ MaxDisparity MaxDisparity MaxDisparity MaxDisparity MaxDisparity maxDisparity ≤ 32767

NumLevelsNumLevelsNumLevelsNumLevelsNumLevelsnumLevels (input_control) integer → (integer)

Anzahl der Pyramidenstufen.

Defaultwert: 1

Werteliste: 1, 2, 3, 4

Restriktion: 1 <= NumLevels

ScoreThreshScoreThreshScoreThreshScoreThreshScoreThreshscoreThresh (input_control) real → (real / integer)

Schwellwert der Korrelationsfunktion.

Defaultwert: 0.0

Werteliste: 0.0, 2.0, 5.0, 10.0

FilterFilterFilterFilterFilterfilter (input_control) string(-array) → (string)

Defaultwert: 'none' "none" "none" "none" "none" "none"

Werteliste: 'left_right_check'"left_right_check""left_right_check""left_right_check""left_right_check""left_right_check", 'none'"none""none""none""none""none"

SubDistanceSubDistanceSubDistanceSubDistanceSubDistancesubDistance (input_control) string(-array) → (string)

Distanz Interpolation.

Defaultwert: 'none' "none" "none" "none" "none" "none"

Werteliste: 'interpolation'"interpolation""interpolation""interpolation""interpolation""interpolation", 'none'"none""none""none""none""none"

Beispiel (HDevelop)

* read the internal and external stereo parameters
read_cam_par ('cam_left.dat', CamParam1)
read_cam_par ('cam_right.dat', CamParam2)
read_pose ('relpose.dat', RelPose)
* compute the mapping for rectified images
gen_binocular_rectification_map (Map1, Map2, CamParam1, CamParam2, \
                                 RelPose, 1, 'geometric', 'bilinear', \
                                 CamParamRect1, CamParamRect2, \
                                 Cam1PoseRect1, Cam2PoseRect2, RelPoseRect)
* compute the distance values in online images
while (1)
  grab_image_async (Image1, AcqHandle1, -1)
  map_image (Image1, Map1, ImageMapped1)

  grab_image_async (Image2, AcqHandle2, -1)
  map_image (Image2, Map2, ImageMapped2)

  binocular_distance (ImageMapped1, ImageMapped2, Distance, Score, \
                      CamParamRect1, CamParam2, RelPoseRect, 'sad', \
                      11, 11, 20, -40, 20, 2, 25, \
                      'left_right_check', 'interpolation')
endwhile

Beispiel (HDevelop)

* read the internal and external stereo parameters
read_cam_par ('cam_left.dat', CamParam1)
read_cam_par ('cam_right.dat', CamParam2)
read_pose ('relpose.dat', RelPose)
* compute the mapping for rectified images
gen_binocular_rectification_map (Map1, Map2, CamParam1, CamParam2, \
                                 RelPose, 1, 'geometric', 'bilinear', \
                                 CamParamRect1, CamParamRect2, \
                                 Cam1PoseRect1, Cam2PoseRect2, RelPoseRect)
* compute the distance values in online images
while (1)
  grab_image_async (Image1, AcqHandle1, -1)
  map_image (Image1, Map1, ImageMapped1)

  grab_image_async (Image2, AcqHandle2, -1)
  map_image (Image2, Map2, ImageMapped2)

  binocular_distance (ImageMapped1, ImageMapped2, Distance, Score, \
                      CamParamRect1, CamParam2, RelPoseRect, 'sad', \
                      11, 11, 20, -40, 20, 2, 25, \
                      'left_right_check', 'interpolation')
endwhile

Beispiel (HDevelop)

* read the internal and external stereo parameters
read_cam_par ('cam_left.dat', CamParam1)
read_cam_par ('cam_right.dat', CamParam2)
read_pose ('relpose.dat', RelPose)
* compute the mapping for rectified images
gen_binocular_rectification_map (Map1, Map2, CamParam1, CamParam2, \
                                 RelPose, 1, 'geometric', 'bilinear', \
                                 CamParamRect1, CamParamRect2, \
                                 Cam1PoseRect1, Cam2PoseRect2, RelPoseRect)
* compute the distance values in online images
while (1)
  grab_image_async (Image1, AcqHandle1, -1)
  map_image (Image1, Map1, ImageMapped1)

  grab_image_async (Image2, AcqHandle2, -1)
  map_image (Image2, Map2, ImageMapped2)

  binocular_distance (ImageMapped1, ImageMapped2, Distance, Score, \
                      CamParamRect1, CamParam2, RelPoseRect, 'sad', \
                      11, 11, 20, -40, 20, 2, 25, \
                      'left_right_check', 'interpolation')
endwhile

Beispiel (C++ (HALCON 5.0-10.0))

// read the internal and external stereo parameters
read_cam_par("cam_left.dat",CamParam1);
read_cam_par("cam_right.dat",CamParam2);
read_pose("relpose.dat",RelPose);
// compute the mapping for rectified images
gen_binocular_rectification_map(&Map1,&Map2,CamParam1,CamParam2,RelPose,1,
                                "geometric","bilinear",&CamParamRect1,
                                &CamParamRect2,&CamPoseRect1,&CamPoseRect2,
                                &RelPoseRect);
// compute the distance values in online images
while (1)
{
  grab_image_async(&Image1,AcqHandle1,-1);
  map_image(Image1,Map1,&ImageMapped1);

  grab_image_async(&Image2,AcqHandle2,-1);
  map_image(Image2,Map2,&ImageMapped2);

  binocular_distance(ImageMapped1,ImageMapped2,&Distance,&Score,
                     CamParamRect1,CamParamRect2,RelPose,"sad",11,11,
                     20,-40,20,2,25,"left_right_check","interpolation");
}

Beispiel (HDevelop)

* read the internal and external stereo parameters
read_cam_par ('cam_left.dat', CamParam1)
read_cam_par ('cam_right.dat', CamParam2)
read_pose ('relpose.dat', RelPose)
* compute the mapping for rectified images
gen_binocular_rectification_map (Map1, Map2, CamParam1, CamParam2, \
                                 RelPose, 1, 'geometric', 'bilinear', \
                                 CamParamRect1, CamParamRect2, \
                                 Cam1PoseRect1, Cam2PoseRect2, RelPoseRect)
* compute the distance values in online images
while (1)
  grab_image_async (Image1, AcqHandle1, -1)
  map_image (Image1, Map1, ImageMapped1)

  grab_image_async (Image2, AcqHandle2, -1)
  map_image (Image2, Map2, ImageMapped2)

  binocular_distance (ImageMapped1, ImageMapped2, Distance, Score, \
                      CamParamRect1, CamParam2, RelPoseRect, 'sad', \
                      11, 11, 20, -40, 20, 2, 25, \
                      'left_right_check', 'interpolation')
endwhile

Beispiel (HDevelop)

* read the internal and external stereo parameters
read_cam_par ('cam_left.dat', CamParam1)
read_cam_par ('cam_right.dat', CamParam2)
read_pose ('relpose.dat', RelPose)
* compute the mapping for rectified images
gen_binocular_rectification_map (Map1, Map2, CamParam1, CamParam2, \
                                 RelPose, 1, 'geometric', 'bilinear', \
                                 CamParamRect1, CamParamRect2, \
                                 Cam1PoseRect1, Cam2PoseRect2, RelPoseRect)
* compute the distance values in online images
while (1)
  grab_image_async (Image1, AcqHandle1, -1)
  map_image (Image1, Map1, ImageMapped1)

  grab_image_async (Image2, AcqHandle2, -1)
  map_image (Image2, Map2, ImageMapped2)

  binocular_distance (ImageMapped1, ImageMapped2, Distance, Score, \
                      CamParamRect1, CamParam2, RelPoseRect, 'sad', \
                      11, 11, 20, -40, 20, 2, 25, \
                      'left_right_check', 'interpolation')
endwhile