fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXld (Operator)

Name

fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXld — Approximieren von bogenförmigen XLD-Konturen durch Ellipsen.

Signatur

Beschreibung

fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXld approximiert die XLD-Konturen ContoursContoursContoursContoursContourscontours durch Ellipsenbögen bzw. geschlossene Ellipsen. Eine Segmentation der Eingabekonturen erfolgt dabei nicht. Es muss also sichergestellt sein, dass jede Kontur in ContoursContoursContoursContoursContourscontours genau einem Ellipsenbogen entspricht. Zurückgegeben wird der Mittelpunkt (RowRowRowRowRowrow, ColumnColumnColumnColumnColumncolumn), die Orientierung der Hauptachse PhiPhiPhiPhiPhiphi und die Länge der großen Radius1Radius1Radius1Radius1Radius1radius1 bzw. der kleinen Halbachse Radius2Radius2Radius2Radius2Radius2radius2 jeder Ellipse. Ellipsenbögen werden zusätzlich durch den Anfangs- und Endwinkel StartPhiStartPhiStartPhiStartPhiStartPhistartPhi und EndPhiEndPhiEndPhiEndPhiEndPhiendPhi des Start- bzw. Endpunktes, sowie den zugehörigen Umlaufsinn PointOrderPointOrderPointOrderPointOrderPointOrderpointOrder charakterisiert. Bei geschlossenen Ellipsen werden die entsprechenden Ausgabeparameter mit 0, und 'positive' besetzt.

Das gewünschte Approximationsverfahren wird über den Parameter AlgorithmAlgorithmAlgorithmAlgorithmAlgorithmalgorithm ausgewählt:

'fitzgibbon'

Minimiert wird der algebraische Abstand

zwischen den Konturpunkten und der gesuchten Ellipse. Durch die Nebenbedingung 4ac - b^2 = 1 wird dabei sichergestellt, dass eine Ellipse (und nicht etwa eine Hyperbel oder Parabel) angepasst wird.

'fhuber'

Wie 'fitzgibbon'. Es wird jedoch eine Gewichtung der Konturpunkte vorgenommen, bei der Ausreißer nach dem Ansatz von Huber gedämpft werden (siehe unten).

'ftukey'

Wie 'fitzgibbon'. Es wird jedoch eine Gewichtung der Konturpunkte vorgenommen, bei der Ausreißer nach dem Ansatz von Tukey ignoriert werden (siehe unten).

'geometric'

Minimiert wird der geometrische Anstand von Konturpunkten und der gesuchten Ellipse. Dieses Fehlermaß ist in einem statistischen Sinne optimal, braucht aber auch eine längere Rechenzeit, da die Berechnung iterative erfolgt. Besonders bei merklich verrauschten Konturpunkten ist die Wahl dieser Option zu empfehlen.

'geohuber'

Wie 'geometric'. Es wird jedoch eine Gewichtung der Konturpunkte vorgenommen, bei der Ausreißer nach dem Ansatz von Huber gedämpft werden (siehe unten).

'geotukey'

Wie 'geometric'. Es wird jedoch eine Gewichtung der Konturpunkte vorgenommen, bei der Ausreißer nach dem Ansatz von Tukey ignoriert werden (siehe unten).

'voss'

Die Eingabekontur wird in eine affine Standardlage transformiert. Dann wird vermöge der Momente der transformierten Kontur (bzw. der davon eingeschlossenen Bildregion) dasjenige Einheitskreissegment bestimmt, dessen Standardlage am besten mit der der transformierten Kontur übereinstimmt. Aus der zugehörigen Ellipse in Standardlage und der affinen Transformation, die die Kontur in Standardlage überführt hat, wird dann die entsprechende Ellipse ermittelt. Es werden VossTabSizeVossTabSizeVossTabSizeVossTabSizeVossTabSizevossTabSize Einheitskreissegment unterschieden (und deren Momente etc. beim ersten Aufruf des Operators tabelliert).

'focpoints'

Für jeden Punkt P auf einer Ellipse gilt, dass die Summe seiner Abstände zu den Brennpunkten der Ellipse gleich dem doppelten Hauptradius a ist. Bei diesem Ansatz wird die Abweichung für alle Konturpunkte durch eine least squares Ausgleichsrechnung minimiert.

'fphuber'

Wie 'focpoints'. Es wird jedoch eine gewichtete Least-Squares-Ausgleichsrechnung durchgeführt, bei der Ausreißer nach dem Ansatz von Huber gedämpft werden (siehe unten).

'fptukey'

Wie 'focpoints'. Es wird jedoch eine gewichtete Least-Squares-Ausgleichsrechnung durchgeführt, bei der Ausreißer nach dem Ansatz von Tukey ignoriert werden (siehe unten).

In den Modi '*huber' und '*tukey' wird eine robuste Fehlerstatistik verwendet, um die Standardabweichung der Abstände der Konturpunkte (ohne Ausreißer) von der approximierenden Ellipse zu ermitteln. Der Parameter ClippingFactorClippingFactorClippingFactorClippingFactorClippingFactorclippingFactor (ein Skalierungsfaktor für diese Standardabweichung) steuert in diesen Modi den Grad der Ausreißerdämpfung: Je kleiner der Wert gewählt wird, desto mehr Punkte werden als Ausreißer behandelt. Jeder Konturpunkt fließt individuell gewichtet in die Berechnung der Ellipsenparameter mit ein. Dieser Prozess kann iteriert werden, und der Parameter IterationsIterationsIterationsIterationsIterationsiterations enthält die Anzahl durchzuführender Iterationen. IterationsIterationsIterationsIterationsIterationsiterations ist relevant für alle Verfahren bis auf die beiden auf dem geometrischen Abstand basierenden Verfahren 'geohuber' und 'geotukey', bei denen dieser Parameter ignoriert wird. Falls der Algorithmus innerhalb dieser Anzahl von Iterationen keine passende Ellipse finden kann, so wird eine Linie gefittet; für Radius2Radius2Radius2Radius2Radius2radius2 wird null zurückgegeben. Ausreißer werden nach dem Ansatz von Tukey komplett eliminiert, während bei dem Verfahren nach Huber diese noch gering, i.e. linear, gewichtet werden. Ohne robuste Gewichtung geht der Abstand quadratisch in die Optimierung mit ein. In der Praxis ist der Ansatz nach Tukey zu emfehlen.

Zur Reduktion des Aufwandes lässt sich die Berechnung auf eine Teilmenge der Konturpunkte einschränken: Wird für MaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsmaxNumPoints eine Zahl ungleich -1 übergeben, werden nur maximal MaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsmaxNumPoints gleichmäßig über die Kontur verteilte Punkte verwendet.

Für Ellipsenbögen, also offene Konturen, werden die Anfangs- und Endpunkte bestimmt, indem zu den Anfangs- und Endpunkten der Eingabekonturen die nächstgelegenen EllipsEndpunkte ermittelt werden. Zurückgegeben werden dann in StartPhiStartPhiStartPhiStartPhiStartPhistartPhi und EndPhiEndPhiEndPhiEndPhiEndPhiendPhi die korrespondierenden Winkel dieser Punkte bezogen auf die Hauptachse der Ellipse, vgl. gen_ellipse_contour_xldgen_ellipse_contour_xldGenEllipseContourXldgen_ellipse_contour_xldGenEllipseContourXldGenEllipseContourXld. Konturen, deren Anfangs- und Endpunkte weniger als MaxClosureDistMaxClosureDistMaxClosureDistMaxClosureDistMaxClosureDistmaxClosureDist voneinander entfernt sind, werden als geschlossen betrachtet und entsprechend durch eine Ellipse approximiert. Für geschlossene Konturen werden die Startwerte der 'focpoints' Algorithmen auf schnellere und weniger genaue Weise geschätzt. Daher können für manche geschlossene Konturen mehr IterationsIterationsIterationsIterationsIterationsiterations notwendig sein. Da die Start- und Endpunkte einer Kontur je nach Vorverarbeitung nicht exakt bekannt sein können, besteht die Möglichkeit, ClippingEndPointsClippingEndPointsClippingEndPointsClippingEndPointsClippingEndPointsclippingEndPoints Punkte am Anfang und Ende der Kontur von der Ellipsenanpassung auszuschließen. Sie werden jedoch weiterhin für die Bestimmung der Anfangs- und Endwinkel verwendet.

Die notwendige, minimale Anzahl an Konturpunkten zur Anpassung einer Ellipse ist fünf. Es wird daher vorausgesetzt, dass die Konturen mindestens Punkte enthalten.

Parallelisierung

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

Parameter

read_image (Image, 'caltab')
find_caltab (Image, CalPlate, 'caltab_800mm.descr', 3, 112, 5)
reduce_domain (Image, CalPlate, ImageReduced)
edges_sub_pix (ImageReduced, Edges, 'lanser2', 0.5, 20, 40)
select_contours_xld (Edges, EdgesClosed, 'closed', 0, 2.0, 0, 0)
select_contours_xld (EdgesClosed, EdgesMarks, 'length', 20, 80, 0, 0)
fit_ellipse_contour_xld (EdgesMarks, 'fitzgibbon', -1, 2, 0, 200, 3, 2.0, \
                         Row, Column, Phi, Radius1, Radius2, StartPhi, \
                         EndPhi, PointOrder)
gen_ellipse_contour_xld (EllMarks, Row, Column, Phi, Radius1, Radius2, \
                         StartPhi, EndPhi, PointOrder, 1.5)
length_xld(EllMarks,Length)

read_image (Image, 'caltab')
find_caltab (Image, CalPlate, 'caltab_800mm.descr', 3, 112, 5)
reduce_domain (Image, CalPlate, ImageReduced)
edges_sub_pix (ImageReduced, Edges, 'lanser2', 0.5, 20, 40)
select_contours_xld (Edges, EdgesClosed, 'closed', 0, 2.0, 0, 0)
select_contours_xld (EdgesClosed, EdgesMarks, 'length', 20, 80, 0, 0)
fit_ellipse_contour_xld (EdgesMarks, 'fitzgibbon', -1, 2, 0, 200, 3, 2.0, \
                         Row, Column, Phi, Radius1, Radius2, StartPhi, \
                         EndPhi, PointOrder)
gen_ellipse_contour_xld (EllMarks, Row, Column, Phi, Radius1, Radius2, \
                         StartPhi, EndPhi, PointOrder, 1.5)
length_xld(EllMarks,Length)

read_image (Image, 'caltab')
find_caltab (Image, CalPlate, 'caltab_800mm.descr', 3, 112, 5)
reduce_domain (Image, CalPlate, ImageReduced)
edges_sub_pix (ImageReduced, Edges, 'lanser2', 0.5, 20, 40)
select_contours_xld (Edges, EdgesClosed, 'closed', 0, 2.0, 0, 0)
select_contours_xld (EdgesClosed, EdgesMarks, 'length', 20, 80, 0, 0)
fit_ellipse_contour_xld (EdgesMarks, 'fitzgibbon', -1, 2, 0, 200, 3, 2.0, \
                         Row, Column, Phi, Radius1, Radius2, StartPhi, \
                         EndPhi, PointOrder)
gen_ellipse_contour_xld (EllMarks, Row, Column, Phi, Radius1, Radius2, \
                         StartPhi, EndPhi, PointOrder, 1.5)
length_xld(EllMarks,Length)

read_image (Image, "caltab");
find_caltab (Image, &CalPlate, "caltab_800mm.descr", 3, 112, 5)
reduce_domain (Image, CalPlate, &ImageReduced);
edges_sub_pix (ImageReduced, &Edges, "lanser2", 0.5, 20, 40);
select_contours_xld (Edges, &EdgesClosed, "closed", 0, 2.0, 0, 0);
select_contours_xld (EdgesClosed, &EdgesMarks, "length", 20, 80, 0, 0);
fit_ellipse_contour_xld (EdgesMarks, "fitzgibbon", -1, 2, 0, 200, 3, 2.0,
                         &Row, &Column, &Phi, &Radius1, &Radius2, &StartPhi,
                         &EndPhi, &PointOrder);
gen_ellipse_contour_xld (&EllMarks, Row, Column, Phi, Radius1, Radius2,
                         StartPhi, EndPhi, PointOrder, 1.5);
length_xld(EllMarks,&Length);

read_image (Image, 'caltab')
find_caltab (Image, CalPlate, 'caltab_800mm.descr', 3, 112, 5)
reduce_domain (Image, CalPlate, ImageReduced)
edges_sub_pix (ImageReduced, Edges, 'lanser2', 0.5, 20, 40)
select_contours_xld (Edges, EdgesClosed, 'closed', 0, 2.0, 0, 0)
select_contours_xld (EdgesClosed, EdgesMarks, 'length', 20, 80, 0, 0)
fit_ellipse_contour_xld (EdgesMarks, 'fitzgibbon', -1, 2, 0, 200, 3, 2.0, \
                         Row, Column, Phi, Radius1, Radius2, StartPhi, \
                         EndPhi, PointOrder)
gen_ellipse_contour_xld (EllMarks, Row, Column, Phi, Radius1, Radius2, \
                         StartPhi, EndPhi, PointOrder, 1.5)
length_xld(EllMarks,Length)

read_image (Image, 'caltab')
find_caltab (Image, CalPlate, 'caltab_800mm.descr', 3, 112, 5)
reduce_domain (Image, CalPlate, ImageReduced)
edges_sub_pix (ImageReduced, Edges, 'lanser2', 0.5, 20, 40)
select_contours_xld (Edges, EdgesClosed, 'closed', 0, 2.0, 0, 0)
select_contours_xld (EdgesClosed, EdgesMarks, 'length', 20, 80, 0, 0)
fit_ellipse_contour_xld (EdgesMarks, 'fitzgibbon', -1, 2, 0, 200, 3, 2.0, \
                         Row, Column, Phi, Radius1, Radius2, StartPhi, \
                         EndPhi, PointOrder)
gen_ellipse_contour_xld (EllMarks, Row, Column, Phi, Radius1, Radius2, \
                         StartPhi, EndPhi, PointOrder, 1.5)
length_xld(EllMarks,Length)

Ergebnis

Sind die Parameterwerte korrekt und konnte eine Ellipsenanpassung durchgeführt werden, liefert fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXld den Wert 2 (H_MSG_TRUE). Das Verhalten bei leerer Eingabe (keine Eingabebilder vorhanden) lässt sich mittels set_system('no_object_result',<Result>)set_system("no_object_result",<Result>)SetSystem("no_object_result",<Result>)set_system("no_object_result",<Result>)SetSystem("no_object_result",<Result>)SetSystem("no_object_result",<Result>) festlegen. Gegebenenfalls wird eine Fehlerbehandlung durchgeführt. Wenn der Parameter ClippingFactorClippingFactorClippingFactorClippingFactorClippingFactorclippingFactor so klein gewählt worden ist, dass alle Punkte als Ausreißer klassifiziert werden, wird die Fehlermeldung 3264 zurückgeliefert.

Vorgänger

gen_contours_skeleton_xldgen_contours_skeleton_xldGenContoursSkeletonXldgen_contours_skeleton_xldGenContoursSkeletonXldGenContoursSkeletonXld, lines_gausslines_gaussLinesGausslines_gaussLinesGaussLinesGauss, lines_facetlines_facetLinesFacetlines_facetLinesFacetLinesFacet, edges_sub_pixedges_sub_pixEdgesSubPixedges_sub_pixEdgesSubPixEdgesSubPix, smooth_contours_xldsmooth_contours_xldSmoothContoursXldsmooth_contours_xldSmoothContoursXldSmoothContoursXld

Nachfolger

gen_ellipse_contour_xldgen_ellipse_contour_xldGenEllipseContourXldgen_ellipse_contour_xldGenEllipseContourXldGenEllipseContourXld, disp_ellipsedisp_ellipseDispEllipsedisp_ellipseDispEllipseDispEllipse, get_points_ellipseget_points_ellipseGetPointsEllipseget_points_ellipseGetPointsEllipseGetPointsEllipse

Siehe auch

fit_line_contour_xldfit_line_contour_xldFitLineContourXldfit_line_contour_xldFitLineContourXldFitLineContourXld, fit_circle_contour_xldfit_circle_contour_xldFitCircleContourXldfit_circle_contour_xldFitCircleContourXldFitCircleContourXld, fit_rectangle2_contour_xldfit_rectangle2_contour_xldFitRectangle2ContourXldfit_rectangle2_contour_xldFitRectangle2ContourXldFitRectangle2ContourXld

Modul

Foundation