Initial commit with project files

3_Signalorientierte_Bildverarbeitung/ü2/README.md

@@ -0,0 +1,25 @@
+# Übung 2: Bildrekonstruktion mit Wiener Filter & Inverser Filterung 
+Gegeben ist eine Abbildung der ETH-Zürich mit einer Bildstörung wie im folgenden zu sehen:
+
+![../../data/eth_blurred.png](../../data/eth_blurred.png)
+
+
+Als Bildstörung ist hier Motion Blur einer gleichförmigen Kamerabewegung von 31 Pixel
+und einem Winkel von 11 Grad (gegen den Uhrzeigersinn) verwendet.
+Berechnen 
+
+# Aufgabe a) Inverse Filterung
+Benutzen Sie inverse Filterung um die Bildstörung (Motion Blur und Rauschen) im Bild
+zu entfernen. Die Inverse Filterung muss anhand der Formeln von der Vorlesung selbst programmiert werden.
+
+Verwenden Sie eine geeignete "cutoff"-Frequenz.
+Nutzen Sie die Datei [a.py](a.py) um Ihre Lösung zu implementieren. In der Datei ist die "Point Spread Function" (PSF)
+bereits implementiert und in den Frequenzbereich transformiert. Die PSF entspricht der Transferfuntkion der
+Bildstörung.
+
+# Aufgabe b) Wiener Filterung
+Nutzen Sie ebenfalls Datei [a.py](a.py),
+Benutzen Sie Wiener Filterung um die Bildstörung (Motion Blur und Rauschen) im Bild
+zu entfernen. Die Wiener Filterung muss anhand der Formeln von der Vorlesung selbst programmiert werden.
+
+Verwenden Sie einen geeigneten Parameter K für den Wiener Filter.

3_Signalorientierte_Bildverarbeitung/ü2/a.py

@@ -0,0 +1,41 @@
+import numpy as np
+import cv2
+
+
+def get_motion_psf(kernel_size, motion_angle, motion_dis):
+    """ "Point Spread Function" um Bewegung zu simulieren """
+    psf = np.zeros(kernel_size)  # point spread function
+    x_center = (kernel_size[0] - 1) / 2
+    y_center = (kernel_size[1] - 1) / 2
+
+    sin_val = np.sin(motion_angle * np.pi / 180)
+    cos_val = np.cos(motion_angle * np.pi / 180)
+
+    for i in range(motion_dis):
+        x_offset = round(sin_val * i)
+        y_offset = round(cos_val * i)
+        psf[int(x_center - x_offset), int(y_center + y_offset)] = 1
+
+    return psf / psf.sum()
+
+
+''' Bild laden und in den Frequenzraum transformieren '''
+img = cv2.imread("../../data/eth_blurred.png", cv2.IMREAD_GRAYSCALE)
+IMG = np.fft.fft2(img)
+
+
+''' Erstellen des Filterkernels und Transformation in den Frequenzraum '''
+rows, cols = img.shape
+h = get_motion_psf(kernel_size=(rows, cols), motion_angle=11, motion_dis=31)
+h = np.fft.fftshift(h) # Muss gemacht werden, da der "Motion Blur Vector" mittig zentriert ist
+H = np.fft.fft2(h)
+
+
+
+
+
+
+''' Ergebnis anzeigen '''
+cv2.imshow("Original", img)
+cv2.imshow("Inverses Filter", img_filtered)
+cv2.waitKey()

3_Signalorientierte_Bildverarbeitung/ü2/l_a.py

@@ -0,0 +1,41 @@
+import numpy as np
+import cv2
+
+
+def get_motion_psf(kernel_size, motion_angle, motion_dis):
+    """ "Point Spread Function" um Bewegung zu simulieren """
+    psf = np.zeros(kernel_size)  # point spread function
+    x_center = (kernel_size[0] - 1) / 2
+    y_center = (kernel_size[1] - 1) / 2
+
+    sin_val = np.sin(motion_angle * np.pi / 180)
+    cos_val = np.cos(motion_angle * np.pi / 180)
+
+    for i in range(motion_dis):
+        x_offset = round(sin_val * i)
+        y_offset = round(cos_val * i)
+        psf[int(x_center - x_offset), int(y_center + y_offset)] = 1
+
+    return psf / psf.sum()
+
+
+''' Bild laden und in den Frequenzraum transformieren '''
+img = cv2.imread("../../data/eth_blurred.png", cv2.IMREAD_GRAYSCALE)
+IMG = np.fft.fft2(img)
+
+
+''' Erstellen des Filterkernels und Transformation in den Frequenzraum '''
+rows, cols = img.shape
+h = get_motion_psf(kernel_size=(rows, cols), motion_angle=11, motion_dis=31)
+h = np.fft.fftshift(h) # Muss gemacht werden, da der "Motion Blur Vector" mittig zentriert ist
+H = np.fft.fft2(h)
+H[np.abs(H) < 0.01] = 0.01  # Begrenzen der Degradationsfunktion um numerische Probleme zu verhindern
+
+''' Inverses Filter anwenden '''
+IMG_FILTERED = IMG / H
+img_filtered = np.fft.ifft2(IMG_FILTERED).clip(0, 255).astype(np.uint8)
+
+''' Ergebnis anzeigen '''
+cv2.imshow("Original", img)
+cv2.imshow("Inverses Filter", img_filtered)
+cv2.waitKey()

3_Signalorientierte_Bildverarbeitung/ü2/l_b.py

@@ -0,0 +1,43 @@
+import numpy as np
+import cv2
+
+
+def get_motion_psf(kernel_size, motion_angle, motion_dis):
+    """ "Point Spread Function" um Bewegung zu simulieren """
+    psf = np.zeros(kernel_size)  # point spread function
+    x_center = (kernel_size[0] - 1) / 2
+    y_center = (kernel_size[1] - 1) / 2
+
+    sin_val = np.sin(motion_angle * np.pi / 180)
+    cos_val = np.cos(motion_angle * np.pi / 180)
+
+    for i in range(motion_dis):
+        x_offset = round(sin_val * i)
+        y_offset = round(cos_val * i)
+        psf[int(x_center - x_offset), int(y_center + y_offset)] = 1
+
+    return psf / psf.sum()
+
+
+''' Bild laden und in den Frequenzraum transformieren '''
+img = cv2.imread("../../data/eth_blurred.png", cv2.IMREAD_GRAYSCALE)
+IMG = np.fft.fft2(img)
+
+
+''' Erstellen des Filterkernels und Transformation in den Frequenzraum '''
+rows, cols = img.shape
+h = get_motion_psf(kernel_size=(rows, cols), motion_angle=11, motion_dis=31)
+h = np.fft.fftshift(h) # Muss gemacht werden, da der "Motion Blur Vector" mittig zentriert ist
+H = np.fft.fft2(h)
+H[np.abs(H) < 0.01] = 0.01  # Begrenzen der Degradationsfunktion um numerische Probleme zu verhindern
+
+''' Wiener Filter anwenden '''
+K = 0.001
+W = np.power(np.abs(H), 2) / (H * np.power(np.abs(H), 2) + K)
+IMG_FILTERED = W * IMG
+img_filtered = np.fft.ifft2(IMG_FILTERED).clip(0, 255).astype(np.uint8)
+
+''' Ergebnis anzeigen '''
+cv2.imshow("Original", img)
+cv2.imshow("Wiener Filter", img_filtered)
+cv2.waitKey()