fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXldfit_ellipse_contour_xld (Operator)

Name

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

Signatur

Beschreibung

fit_ellipse_contour_xldfit_ellipse_contour_xldFitEllipseContourXldFitEllipseContourXldFitEllipseContourXldfit_ellipse_contour_xld approximiert die XLD-Konturen ContoursContoursContoursContourscontourscontours durch Ellipsenbögen bzw. geschlossene Ellipsen. Eine Segmentierung 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 Radius1Radius1Radius1Radius1radius1radius_1 bzw. der kleinen Halbachse Radius2Radius2Radius2Radius2radius2radius_2 jeder Ellipse. Ellipsenbögen werden zusätzlich durch den Anfangs- und Endwinkel StartPhiStartPhiStartPhiStartPhistartPhistart_phi und EndPhiEndPhiEndPhiEndPhiendPhiend_phi des Start- bzw. Endpunktes, sowie den zugehörigen Umlaufsinn PointOrderPointOrderPointOrderPointOrderpointOrderpoint_order 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'"fitzgibbon""fitzgibbon""fitzgibbon""fitzgibbon""fitzgibbon"

Minimiert wird der algebraische Abstand zwischen den Konturpunkten und der gesuchten Ellipse. Durch die Nebenbedingung wird dabei sichergestellt, dass eine Ellipse (und nicht etwa eine Hyperbel oder Parabel) angepasst wird.

'fhuber'"fhuber""fhuber""fhuber""fhuber""fhuber"

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

'ftukey'"ftukey""ftukey""ftukey""ftukey""ftukey"

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

'geometric'"geometric""geometric""geometric""geometric""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'"geohuber""geohuber""geohuber""geohuber""geohuber"

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

'geotukey'"geotukey""geotukey""geotukey""geotukey""geotukey"

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

'voss'"voss""voss""voss""voss""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 VossTabSizeVossTabSizeVossTabSizeVossTabSizevossTabSizevoss_tab_size Einheitskreissegment unterschieden (und deren Momente etc. beim ersten Aufruf des Operators tabelliert).

'focpoints'"focpoints""focpoints""focpoints""focpoints""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'"fphuber""fphuber""fphuber""fphuber""fphuber"

Wie 'focpoints'"focpoints""focpoints""focpoints""focpoints""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'"fptukey""fptukey""fptukey""fptukey""fptukey"

Wie 'focpoints'"focpoints""focpoints""focpoints""focpoints""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 ClippingFactorClippingFactorClippingFactorClippingFactorclippingFactorclipping_factor (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'"geohuber""geohuber""geohuber""geohuber""geohuber" und 'geotukey'"geotukey""geotukey""geotukey""geotukey""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 Radius2Radius2Radius2Radius2radius2radius_2 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 empfehlen.

Zur Reduktion des Aufwandes lässt sich die Berechnung auf eine Teilmenge der Konturpunkte einschränken: Wird für MaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsmaxNumPointsmax_num_points eine Zahl ungleich -1 übergeben, werden nur maximal MaxNumPointsMaxNumPointsMaxNumPointsMaxNumPointsmaxNumPointsmax_num_points 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 Ellipsenendpunkte ermittelt werden. Zurückgegeben werden dann in StartPhiStartPhiStartPhiStartPhistartPhistart_phi und EndPhiEndPhiEndPhiEndPhiendPhiend_phi die korrespondierenden Winkel dieser Punkte bezogen auf die Hauptachse der Ellipse, vgl. gen_ellipse_contour_xldgen_ellipse_contour_xldGenEllipseContourXldGenEllipseContourXldGenEllipseContourXldgen_ellipse_contour_xld. Konturen, deren Anfangs- und Endpunkte weniger als MaxClosureDistMaxClosureDistMaxClosureDistMaxClosureDistmaxClosureDistmax_closure_dist voneinander entfernt sind, werden als geschlossen betrachtet und entsprechend durch eine Ellipse approximiert. Für geschlossene Konturen werden die Startwerte der 'focpoints'"focpoints""focpoints""focpoints""focpoints""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, ClippingEndPointsClippingEndPointsClippingEndPointsClippingEndPointsclippingEndPointsclipping_end_points 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.

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

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_xldFitEllipseContourXldFitEllipseContourXldFitEllipseContourXldfit_ellipse_contour_xld 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>)SetSystem("no_object_result",<Result>)SetSystem("no_object_result",<Result>)set_system("no_object_result",<Result>) festlegen. Gegebenenfalls wird eine Fehlerbehandlung durchgeführt. Wenn der Parameter ClippingFactorClippingFactorClippingFactorClippingFactorclippingFactorclipping_factor 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_xldGenContoursSkeletonXldGenContoursSkeletonXldGenContoursSkeletonXldgen_contours_skeleton_xld, lines_gausslines_gaussLinesGaussLinesGaussLinesGausslines_gauss, lines_facetlines_facetLinesFacetLinesFacetLinesFacetlines_facet, edges_sub_pixedges_sub_pixEdgesSubPixEdgesSubPixEdgesSubPixedges_sub_pix, smooth_contours_xldsmooth_contours_xldSmoothContoursXldSmoothContoursXldSmoothContoursXldsmooth_contours_xld

Nachfolger

gen_ellipse_contour_xldgen_ellipse_contour_xldGenEllipseContourXldGenEllipseContourXldGenEllipseContourXldgen_ellipse_contour_xld, disp_ellipsedisp_ellipseDispEllipseDispEllipseDispEllipsedisp_ellipse, get_points_ellipseget_points_ellipseGetPointsEllipseGetPointsEllipseGetPointsEllipseget_points_ellipse

Siehe auch

fit_line_contour_xldfit_line_contour_xldFitLineContourXldFitLineContourXldFitLineContourXldfit_line_contour_xld, fit_circle_contour_xldfit_circle_contour_xldFitCircleContourXldFitCircleContourXldFitCircleContourXldfit_circle_contour_xld, fit_rectangle2_contour_xldfit_rectangle2_contour_xldFitRectangle2ContourXldFitRectangle2ContourXldFitRectangle2ContourXldfit_rectangle2_contour_xld

Modul

Foundation