imported>AsepTisch: Änderungen von ~2025-28543-40 (Diskussion) wurden auf die letzte Version von Dennisgmt zurückgesetzt: keine Verbesserung

2025-10-12T17:56:14Z

Änderungen von ~2025-28543-40 (Diskussion) wurden auf die letzte Version von Dennisgmt zurückgesetzt: keine Verbesserung

Neue Seite

Der '''Sobel-Operator'''<ref>Irwin Sobel, 2014, [https://www.researchgate.net/publication/239398674_An_Isotropic_3_3_Image_Gradient_Operator ''Geschichte und Definition des Sobel-Operators'' (englisch)]</ref> ist ein einfacher [[Kantendetektion]]s-[[Filter (Bildverarbeitung)|Filter]], der in der [[Bildverarbeitung]] häufig Anwendung findet und dort mithilfe der [[Faltung (Mathematik)|Faltung]] als [[Algorithmus]] eingesetzt wird. Dieser berechnet die erste [[Differentialrechnung|Ableitung]] der [[Pixel|Bildpunkt]]-Helligkeitswerte, wobei gleichzeitig [[Orthogonalität|orthogonal]] zur Ableitungsrichtung geglättet wird.

Der [[Algorithmus]] nutzt eine [[Faltung (Mathematik)|Faltung]] mittels einer 3×3-[[Matrix (Mathematik)|Matrix]] ([[Faltungsmatrix]]), die aus dem Originalbild ein [[Gradient (Mathematik)|Gradienten]]-Bild erzeugt. Mit diesem werden hohe Frequenzen im Bild mit [[Grauwert]]en dargestellt. Die Bereiche der größten Intensität sind dort, wo sich die Helligkeit des Originalbildes am stärksten ändert und somit die größten Kanten darstellt. Daher wird zumeist nach der Faltung mit dem Sobel-Operator eine [[Schwellenwertverfahren|Schwellenwert]]-Funktion angewandt. Der Algorithmus kann allerdings auch auf andere [[2D|zweidimensionale]] Signale angewandt werden.

== In Formeln ==
Aus dem Originalbild <math>A</math> wird für jedes [[Pixel]] immer nur ein Ausschnitt, genauer gesagt die Umgebung des zu betrachtenden Pixels, verwendet. Nun werden mittels der Sobel-Operatoren
:<math>
\mathbf{S}_x = \begin{bmatrix}
1 \\
2 \\
1
\end{bmatrix} * \begin{bmatrix}
-1 & 0 & 1
\end{bmatrix} </math>       und       <math>
\mathbf{S}_y = \left[\begin{array}{r}
-1 \\
0 \\
1
\end{array}\right] * \begin{bmatrix}
1 & 2 & 1
\end{bmatrix}
</math>
die gefalteten Resultate
:<math>
\mathbf{G}_x=\mathbf{S}_x * A = \begin{bmatrix}
-1 & 0 & 1 \\
-2 & 0 & 2 \\
-1 & 0 & 1
\end{bmatrix} * A
</math>
und
:<math>\mathbf{G}_y=\mathbf{S}_y * A = \left[\begin{array}{r}
-1 & -2 & -1 \\
0 & 0 & 0 \\
1 & 2 & 1
\end{array}\right] * A
</math>
berechnet. Dabei wird die <math>x</math>-Koordinate als nach rechts und die <math>y</math>-Koordinate als nach unten wachsend angesehen.
Durch Ausnutzung der [[Separierbarkeit]] kann die [[Rechenzeit]] deutlich reduziert werden.

Anschließend werden alle Elemente der [[Matrix (Mathematik)|Matrix]] aufsummiert, um ihren [[Grauwert]] zu erhalten (siehe [[Grauwertematrix]]). Eine richtungsunabhängige [[Information]] kann man durch die Kombination beider Ergebnisse erhalten:
:<math>\mathbf{G} = \sqrt{ \mathbf{G}_x^2 + \mathbf{G}_y^2 }.</math>

Die [[Richtung]] eines [[Gradient (Mathematik)|Gradienten]] erhält man über die [[Formel]]
:<math>\Theta = \operatorname{arctan2}\left( \mathbf{G}_x , \mathbf{G}_y \right)</math>,
wobei [[arctan2]] der [[Arkustangens und Arkuskotangens|Arkustangens]] mit zwei [[Argument (Informatik)|Argumenten]] ist. Durch den Wert <math>\Theta = 0</math> wird eine vertikale Kante beschrieben, mit negativem [[Gradient]]en in <math>x</math>-[[Richtung]]. Die [[Winkel]] nehmen zu bei einer [[Drehung]] im [[Uhrzeigersinn]].

== Programmierung ==
Das folgende Beispiel in der [[Programmiersprache]] [[C-Sharp|C#]] zeigt die Implementierung des Sobel-Operators. Die hier gezeigte [[Methode (Programmierung)|Methode]] erzeugt aus einem Originalbild ein [[Gradient (Mathematik)|Gradienten]]-Bild. Die [[Pixel]] haben als Farbwerte den richtungsunabhängigen Gradienten <math>\mathbf{G}</math>.<ref>https://stackoverflow.com/questions/17815687/image-processing-implementing-sobel-filter</ref><syntaxhighlight lang="c#">
// Erzeugt ein richtungsunabhängiges Gradienten-Bild aus einem Originalbild mithilfe der Sobel-Operatoren S_x und S_y
public Bitmap GetGradientImage(string imageFilePath)
{
Bitmap image = new Bitmap(imageFilePath); // Lädt ein Bitmap aus einer Bilddatei.

// Initialisiert ein 2-dimensionales Array für den Sobel-Operator S_x
double[][] S_x = new double[][]{new double[]{-1,0,1}, new double[]{-2,0,2}, new double[]{-1,0,1}};
// Initialisiert ein 2-dimensionales Array für den Sobel-Operator S_y
double[][] S_y = new double[][]{new double[]{-1,-2,-1}, new double[]{0,0,0}, new double[]{1,2,1}};

// Erzeugt ein neues Bitmap für das Gradienten-Bild.
Bitmap gradientImage = new Bitmap(image.Width, image.Height);

// Durchläuft das Originalbild entlang der x-Achse.
for (int x = 0; x < image.Width - 2; x++)
{
// Durchläuft das Originalbild entlang der y-Achse.
for (int y = 0; y < image.Height - 2; y++)
{
// Berechnet den Gradienten G_x
double G_x = (S_x[0][0] * image.GetPixel(x,y).R) + (S_x[0][1] * image.GetPixel(x+1,y).R) + (S_x[0][2] * image.GetPixel(x+2,y).R) +
(S_x[1][0] * image.GetPixel(x,y+1).R) + (S_x[1][1] * image.GetPixel(x+1,y+1).R) + (S_x[1][2] * image.GetPixel(x+2,y+1).R) +
(S_x[2][0] * image.GetPixel(x,y+2).R) + (S_x[2][1] * image.GetPixel(x+1,y+2).R) + (S_x[2][2] * image.GetPixel(x+2,y+2).R);
// Berechnet den Gradienten G_y
double G_y = (S_y[0][0] * image.GetPixel(x,y).R) + (S_y[0][1] * image.GetPixel(x+1,y).R) + (S_y[0][2] * image.GetPixel(x+2,y).R) +
(S_y[1][0] * image.GetPixel(x,y+1).R) + (S_y[1][1] * image.GetPixel(x+1,y+1).R) + (S_y[1][2] * image.GetPixel(x+2,y+1).R) +
(S_y[2][0] * image.GetPixel(x,y+2).R) + (S_y[2][1] * image.GetPixel(x+1,y+2).R) + (S_y[2][2] * image.GetPixel(x+2,y+2).R);

// Berechnet den richtungsunabhängigen Gradienten G.
int G = (int) Math.Sqrt((G_x * G_x) + (G_y * G_y));
// Setzt den Farbwert für das Pixel des Gradienten-Bilds.
gradientImage.SetPixel(x, y, Color.FromArgb(G, G, G));
}
}
return gradientImage; // Gibt das Gradienten-Bild als Rückgabewert der Methode zurück.
}
</syntaxhighlight>

== Beispielbilder ==
{|
| valign="top" |[[Datei:Camera obscura.jpg|mini|Originalbild "Camera Obscura", das zur weiteren Berechnung verwendet wurde.]]
| valign="top" |[[Datei:Camera obscura-Sobel-Horizontal.jpg|mini|Camera Obscura mit Sobel-Operator <math>\mathbf{G_x}</math> gefiltert (detektiert vertikale Kanten). Da auch negative Werte entstehen, wird der Nullpunkt als mittleres Grau dargestellt]]
| valign="top" |[[Datei:Camera obscura-Sobel-Vertikal.jpg|mini|Camera Obscura mit Sobel-Operator <math>\mathbf{G_y}</math> gefiltert (detektiert horizontale Kanten). Da auch negative Werte entstehen, wird der Nullpunkt als mittleres Grau dargestellt]]
| valign="top" |[[Datei:Camera obscura-Sobel-Kombination.jpg|mini|Camera Obscura mit Sobel-Operatoren <math>\mathbf{G}_x</math> und <math>\mathbf{G}_y</math> gefiltert, kombiniert und mit Absolutwerten dargestellt.]]
|}
== Software ==
Der Sobel-Operator kann mit dem [[Grafikprogramm]] [[GIMP]]<ref>{{Internetquelle |autor= |url=https://docs.gimp.org/2.8/de/plug-in-sobel.html |titel=7.6. Sobel |werk=GNU Image Manipulation Program - Benutzerhandbuch |hrsg=GIMP |datum= |zugriff=2018-11-29}}</ref> über die Menüaufrufe Filter → Kanten finden → Sobel ausgeführt werden. In den freien Bildverarbeitungsbibliotheken [[Scikit-image]]<ref>{{Internetquelle |autor= |url=https://scikit-image.org/docs/dev/api/skimage.filters.html#skimage.filters.sobel |titel=Module: filters — skimage v0.15.dev0 docs |werk= |hrsg= |datum= |zugriff=2018-11-29 |sprache=en}}</ref> und [[OpenCV]]<ref>{{Internetquelle |autor= |url=https://docs.opencv.org/master/d2/d2c/tutorial_sobel_derivatives.html |titel=OpenCV: Sobel Derivatives |werk= |hrsg= |datum= |zugriff=2018-11-29 |sprache=en}}</ref> ist er ebenfalls implementiert.

== Scharr-Operator ==
Der Sobel-Operator hat keine perfekte [[Rotationssymmetrie]]. Besser berücksichtigt wird dies mit dem Scharr-Operator<ref>[https://nbn-resolving.org/urn/resolver.pl?urn=urn:nbn:de:bsz:16-opus-9622 ''Scharr, Hanno. Optimale Operatoren in der Digitalen Bildverarbeitung. Dissertation: Ruprecht-Karls-Universität Heidelberg, 2000''].</ref>:

:<math>
\mathbf{G}_x= \begin{bmatrix}
47 & 0 & -47 \\
162 & 0 & -162 \\
47 & 0 & -47
\end{bmatrix} * A
</math>

und

:<math>\mathbf{G}_y= \begin{bmatrix}
47 & 162 & 47 \\
0 & 0 & 0 \\
-47 & -162 & -47
\end{bmatrix} * A
</math>

== 5×5 Sobel Varianten ==
Es gibt auch Ansätze die Sobel-Faltungsmatrix auf 5×5 zu vergrößern<ref>[https://www.mathship.com/730/SobelGradients5x5.pdf '' G. Levkine. Sobel and Scharr 3x3 and 5x5 convolution kernels for image gradient calculations, (2020)''].</ref><ref>[https://www.researchgate.net/publication/49619233_Image_Segmentation_using_Extended_Edge_Operator_for_Mammographic_Images ''Prof. Kekre. Image Segmentation using Extended Edge Operator for Mammographic Images, (2010)''].</ref>. Alternativ kann man vorab einen Weichzeichner (z. B. 3×3 Blur) anwenden mit ähnlichem Ergebnis.

== Siehe auch ==

* [[Kantendetektion]]

* [[Prewitt-Operator]]
* [[Roberts-Operator]]
* [[Canny-Algorithmus]]
* [[Laplace-Filter]]
* [[Kirsch-Operator]] (nicht linear)

== Einzelnachweise ==
<references />

[[Kategorie:Kantendetektion]]
[[Kategorie:Bildverarbeitung]]

Sobel-Operator - Versionsgeschichte

imported>AsepTisch: Änderungen von ~2025-28543-40 (Diskussion) wurden auf die letzte Version von Dennisgmt zurückgesetzt: keine Verbesserung