Sobel-Operator

Der Sobel-Operator^[1] ist ein einfacher Kantendetektions-Filter, der in der Bildverarbeitung häufig Anwendung findet und dort mithilfe der Faltung als Algorithmus eingesetzt wird. Dieser berechnet die erste Ableitung der Bildpunkt-Helligkeitswerte, wobei gleichzeitig orthogonal zur Ableitungsrichtung geglättet wird.

Der Algorithmus nutzt eine Faltung mittels einer 3×3-Matrix (Faltungsmatrix), die aus dem Originalbild ein Gradienten-Bild erzeugt. Mit diesem werden hohe Frequenzen im Bild mit Grauwerten 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 Schwellenwert-Funktion angewandt. Der Algorithmus kann allerdings auch auf andere zweidimensionale Signale angewandt werden.

Aus dem Originalbild ${\displaystyle A}$ wird für jedes Pixel immer nur ein Ausschnitt, genauer gesagt die Umgebung des zu betrachtenden Pixels, verwendet. Nun werden mittels der Sobel-Operatoren

${\displaystyle \mathbf {S} _{x}={\begin{bmatrix}1\\2\\1\end{bmatrix}}*{\begin{bmatrix}-1&0&1\end{bmatrix}}}$       und       ${\displaystyle \mathbf {S} _{y}=\left[{\begin{array}{r}-1\\0\\1\end{array}}\right]*{\begin{bmatrix}1&2&1\end{bmatrix}}}$

die gefalteten Resultate

${\displaystyle \mathbf {G} _{x}=\mathbf {S} _{x}*A={\begin{bmatrix}-1&0&1\\-2&0&2\\-1&0&1\end{bmatrix}}*A}$

und

${\displaystyle \mathbf {G} _{y}=\mathbf {S} _{y}*A=\left[{\begin{array}{r}-1&-2&-1\\0&0&0\\1&2&1\end{array}}\right]*A}$

berechnet. Dabei wird die ${\displaystyle x}$-Koordinate als nach rechts und die ${\displaystyle y}$-Koordinate als nach unten wachsend angesehen. Durch Ausnutzung der Separierbarkeit kann die Rechenzeit deutlich reduziert werden.

Anschließend werden alle Elemente der Matrix aufsummiert, um ihren Grauwert zu erhalten (siehe Grauwertematrix). Eine richtungsunabhängige Information kann man durch die Kombination beider Ergebnisse erhalten:

${\displaystyle \mathbf {G} ={\sqrt {\mathbf {G} _{x}^{2}+\mathbf {G} _{y}^{2}}}.}$

Die Richtung eines Gradienten erhält man über die Formel

${\displaystyle \Theta =\operatorname {arctan2} \left(\mathbf {G} _{x},\mathbf {G} _{y}\right)}$,

wobei arctan2 der Arkustangens mit zwei Argumenten ist. Durch den Wert ${\displaystyle \Theta =0}$ wird eine vertikale Kante beschrieben, mit negativem Gradienten in ${\displaystyle x}$-Richtung. Die Winkel nehmen zu bei einer Drehung im Uhrzeigersinn.

Das folgende Beispiel in der Programmiersprache C# zeigt die Implementierung des Sobel-Operators. Die hier gezeigte Methode erzeugt aus einem Originalbild ein Gradienten-Bild. Die Pixel haben als Farbwerte den richtungsunabhängigen Gradienten ${\displaystyle \mathbf {G} }$.^[2]

// 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.
}

Der Sobel-Operator kann mit dem Grafikprogramm GIMP^[3] über die Menüaufrufe Filter → Kanten finden → Sobel ausgeführt werden. In den freien Bildverarbeitungsbibliotheken Scikit-image^[4] und OpenCV^[5] ist er ebenfalls implementiert.

Der Sobel-Operator hat keine perfekte Rotationssymmetrie. Besser berücksichtigt wird dies mit dem Scharr-Operator^[6]:

${\displaystyle \mathbf {G} _{x}={\begin{bmatrix}47&0&-47\\162&0&-162\\47&0&-47\end{bmatrix}}*A}$

und

${\displaystyle \mathbf {G} _{y}={\begin{bmatrix}47&162&47\\0&0&0\\-47&-162&-47\end{bmatrix}}*A}$

Es gibt auch Ansätze die Sobel-Faltungsmatrix auf 5×5 zu vergrößern^[7][8]. Alternativ kann man vorab einen Weichzeichner (z. B. 3×3 Blur) anwenden mit ähnlichem Ergebnis.

• Kantendetektion

• Prewitt-Operator
• Roberts-Operator
• Canny-Algorithmus
• Laplace-Filter
• Kirsch-Operator (nicht linear)

1. ↑ Irwin Sobel, 2014, Geschichte und Definition des Sobel-Operators (englisch)
2. ↑ https://stackoverflow.com/questions/17815687/image-processing-implementing-sobel-filter
3. ↑ 7.6. Sobel. In: GNU Image Manipulation Program - Benutzerhandbuch. GIMP, abgerufen am 29. November 2018. 
4. ↑ Module: filters — skimage v0.15.dev0 docs. Abgerufen am 29. November 2018 (englisch). 
5. ↑ OpenCV: Sobel Derivatives. Abgerufen am 29. November 2018 (englisch). 
6. ↑ Scharr, Hanno. Optimale Operatoren in der Digitalen Bildverarbeitung. Dissertation: Ruprecht-Karls-Universität Heidelberg, 2000.
7. ↑ G. Levkine. Sobel and Scharr 3x3 and 5x5 convolution kernels for image gradient calculations, (2020).
8. ↑ Prof. Kekre. Image Segmentation using Extended Edge Operator for Mammographic Images, (2010).