Initial commit with project files

0_Einführung/README.md

@@ -0,0 +1,93 @@
+# Einführung
+In diesem Kapitel werden Sie mit den nötigen Werkzeugen ausgestattet, um diesen Kurs zu meistern.
+Dafür wird ihnen gezeigt, wie Sie dieses Repository korrekt auf Ihren Rechner installieren. 
+Sie werden grundlegend in die Programmiersprache Python und die Programmierumgebung PyCharm eingeführt. Arbeiten Sie die
+folgenden Abschnitte in der gegebenen Reihenfolge durch.
+
+**Hinweis:** Sollten Sie bereits Erfahrung mit Github, Python und Pycharm haben, können Sie dieses Einführung überspringen.
+
+## Installation Python
+Installieren Sie den Python-Interpreter in der Version 3.5 oder höher. Die Installation ist Abhängig von Ihrem Betriebssystem.
+
+Für das Betriebssystem
+ - **Windows** finden Sie Python zum Download auf [https://www.python.org/downloads/windows/](https://www.python.org/downloads/windows/)
+ - **Mac OS** finden Sie Python zum Download auf [https://www.python.org/downloads/mac-osx/](https://www.python.org/downloads/mac-osx/)
+ - **Linux** ist Python auf den meisten Distributionen vorinstalliert
+
+Eine detailliertes Tutorial zu Python finden Sie unter [https://wiki.python.org/moin/BeginnersGuide](https://wiki.python.org/moin/BeginnersGuide).
+
+## Installation PyCharm Community Edition
+Die Programmierumgebung PyCharm ist eine für private- und Lehrzwecke frei verfügbare Software, welche die Arbeit mit
+Python sehr stark vereinfacht. Die Verwendung von PyCharm ist für diesen Kurs nicht notwendig aber dringend empfohlen!
+
+Die Installation geschieht auf jedem Betriebssystem mithilfe einer Installationsdatei, welche für
+ - **Windows** unter [https://www.jetbrains.com/de-de/pycharm/download/#section=windows](https://www.jetbrains.com/de-de/pycharm/download/#section=windows)
+ - **Mac OS** unter [https://www.jetbrains.com/de-de/pycharm/download/#section=mac](https://www.jetbrains.com/de-de/pycharm/download/#section=mac)
+ - **Linux** unter [https://www.jetbrains.com/de-de/pycharm/download/#section=linux](https://www.jetbrains.com/de-de/pycharm/download/#section=linux)
+ 
+erhältlich ist.
+
+**Hinweis:** Sollten Sie Interesse an zusätzlichen Funktionen haben, können Sie als Student eine zeitlich limitierte 
+kostenlose *PyCharm-Professional*  Lizenz für Lehrzwecke erwerben. Weitere Informationen finden Sie unter
+[https://www.jetbrains.com/de-de/community/education/#students](https://www.jetbrains.com/de-de/community/education/#students).
+
+## Download der Daten
+Wenn Sie diesen Text lesen, werden Sie das Github Repository vermutlich bereits gefunden haben. Der Kurs wird auf der Platform
+Github gehosted, um die Aufgaben kontinuierlich weiterentwickeln zu können und Ihnen dabei stets Zugriff auf den
+neusten Entwicklungsstand zu geben. Weiterhin bietet Github die Möglichkeit, dass Sie aktiv bei der Mitgestaltung dieses
+Kurses beitragen können.
+
+Der Download der Daten kann entweder über **Git** oder die einfache **Download-Funktion** geschehen. Es wird die
+Methode Git empfohlen. Weitere Informationen zu Git finden Sie unter 
+[https://guides.github.com/introduction/git-handbook/](https://guides.github.com/introduction/git-handbook/).
+
+Sollten Sie sich gegen Git und für die Download-Funktion entscheiden, können Sie den Download wie im folgenden Bild 
+gezeigt starten.
+
+![alt text](./data/git_download.png)
+
+Downloaden und speichern Sie die Daten an einem beliebigen Pfad, z.B. `C:\Users\Timo\Desktop\Digitale-Bildverarbeitung`.
+Im folgenden wird der von Ihnen ausgesuchte Pfad als `WORKING_DIRECTORY` beschrieben. Sollten Sie die Daten erfolgreich
+gespeichert haben, sollte diese README-Datei an der Stelle `WORKING_DIRECTORY\0_Einführung\README.md` liegen.  
+
+**Hinweis:** Sie sind herzlich dazu eingeladen Git *Merge Requests* zu verwenden, um eventuelle Fehler zu korrigieren oder 
+neue Aufgaben zu erstellen.
+
+## Einrichtung einer Virtuellen Umgebung
+Starten Sie PyCharm und erstellen Sie ein neues Projekt. Es wird ein Dialog geöffnet, welcher ähnlich der folgenden 
+Abbildung aussieht. 
+
+![alt text](./data/pycharm1.png)
+Wählen Sie ihr `WORKIND_DIRECTORY` in dem Feld *Location* aus und wählen Sie als Projekt Interpreter
+*New environment using* und *Virtualenv* aus. Die Initialisierung kann einen Moment dauern! 
+
+Nachdem die Umgebung erfolgreich erstellt wurde, sollten Sie das Programm PyCharm in etwa wie in der nächsten Abbildung
+dargstellt sehen.
+
+Die rot markierten Felder **Explorer**, **Editor**, **Run** und **Terminal** sind für Ihre Arbeit von besonderem Interesse.
+Dabei ist
+ - **Explorer** eine Projektübersicht, um zwischen den Dateien des Projektes zu wechseln
+ - **Editor** ein Fenster, um Dateien zu bearbeiten
+ - **Run** das Ausgabefenster eines Python Programms
+ - **Terminal** eine interne Kommandozeile
+ 
+![alt text](./data/pycharm2.png)
+
+Wenn Sie den Reiter `File/Settings/Project: Digitale-Bildverarbeitung/Project Interpreter` (variiert leicht bei den Betriebssystemen!)
+öffnen, sollte die Ausgabe ähnlich zu der folgenden Abbildung sein. Die Anzahl der Packages kann dabei deutlich geringer sein. 
+![alt text](./data/pycharm3.png)
+
+Wechseln Sie nun in das Terminal und verwenden foldende Befehle:
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install pipenv
+pipenv install --skip-lock
+```
+Die Ausführung kann einen Moment dauern! Verwenden Sie folgenden Befehl um die korrekte Installation zu testen:
+
+```bash
+python 0_Einführung/test_installation.py
+```
+
+Herzlichen Glückwunsch, Sie haben den Kurs erfolgreich eingerichtet!

0_Einführung/test_installation.py

@@ -0,0 +1,13 @@
+import cv2
+import matplotlib
+import numpy as np
+import platform
+
+if cv2.__version__ and np.__version__ and matplotlib.__version__:
+    print("Digital Image Processing is fun!")
+    print("OpenCV version:", cv2.__version__)
+    print("NumPy version:", np.__version__)
+    print("Matplotlib version:", matplotlib.__version__)
+    print("Python version:", platform.python_version())
+else:
+    print("OpenCV, NumPy and/or Matplotlib are not installed.")

0_Einführung/ü1/README.md

@@ -0,0 +1,56 @@
+# Übung 1: Grundlagen Python
+
+Das Erlernen der Programmiersprache Python gehört nicht zum Anspruch dieses Kurses. Trotzdem sollen einige grundlegende
+Funktionen und Konventionen aus Python erläutert werden. Im Folgenden wird das simple Beispielprogramm erläutert:
+
+````python
+# Beispielprogramm
+import numpy as np
+
+print(np.pi)
+
+variable1 = 10
+variable2 = [variable1, variable1 + 10, variable1 + 20]
+
+print(variable2[0])
+print(variable2[1])
+print(variable2[2])
+
+for var in variable2:
+    if (var / 10)  % 2 == 1:
+        print("Die erste Ziffer Zahl %s ist ungerade!" % var)
+
+````
+## Imports
+Es existieren viele vorgefertigte Pakete in Python. Sie können diese importieren, indem Sie ``import PAKET `` verwenden.
+Im Beispielcode wird *numpy* importiert und mit dem Namen *np* versehen. Daraufhin können Sie auf Funktionen des Pakets
+zugreifen, wie z.B. in Zeile 4 ``print(np.pi)``, in welcher der Werit von Pi ausgegben wird. Nutzen Sie Imports nach 
+Möglichkeit immer zu Beginn ihres Skripts.
+
+## Variablen
+In Python können Sie Variablen definieren, ohne einen Typ anzugeben. Im folgenden werden einige Typen gezeigt:
+
+````python
+a = "Ein Text"  # string
+b = 2           # int
+c = 3.4         # float
+d = [2, 3, 4]   # list
+e = (2, 3, 4)   # tuple
+````
+Besondere Variablentypen sind Listen oder Tupel. Sie sind Container für mehrere andere Variablen. Auf die einzelnen
+Elemente der Liste/Tupel kann mit einem Index zugegriffen werden:
+
+````python
+a = [2, 3, 4]   # list
+b = a[0]        # Entspricht dem Wert 2
+````
+
+Die Indizierung beginnt bei dem Wert 0. 
+
+## print()
+Sie können Werte oder Texte ausgeben, indem Sie den Befehl ``print(IRGENDEINE_VARIABLE)`` verwenden. 
+Sie müssen die Variablen vorher nicht zum Datentyp *string* konvertieren.
+
+## Schleifen
+
+Bitte recherchieren Sie zum Thema Schleifen unter [https://www.python-kurs.eu/schleifen.php](https://www.python-kurs.eu/schleifen.php).

0_Einführung/ü2/README.md

@@ -0,0 +1,14 @@
+# Übung 2: Grundlagen Matrix-Operationen mit *Numpy*
+
+In dieser Übung werden Ihnen grundlegende Matrixoperationen mit *numpy* erläutert. Das Python Paket *numpy* ist eine der
+meistverwendeten Pakete für mathematische Funktionen und Grundlage für viele andere Python Pakete. Eine detaillierte
+Dokumentation finden Sie unter [https://numpy.org/](https://numpy.org/).
+
+Einige Grundlegende Funktionen werden in dieser Übung gezeigt.
+
+# Aufgabe a)
+Schauen Sie sich das Tutorial in [https://www.programiz.com/python-programming/matrix](https://www.programiz.com/python-programming/matrix) an und verstehen Sie die 
+Anwendung von Matrizen in *Numpy*!
+
+# Aufgabe b)
+Öffnen Sie die Datei [b.py](b.py) und machen Sie sich mit den Teilaufgaben vertraut.  

0_Einführung/ü2/b.py

@@ -0,0 +1,50 @@
+"""
+ÜBUNG 1
+
+In dieser Übung soll der Umgang mit grundlegenden Matrix-Operationen mithilfe von numpy erlernt werden.
+
+"""
+
+import numpy as np
+
+'''
+a) Erstelle einen Zeilenvektor mit den Einträgen 1, 2, 3 
+'''
+
+'''
+b) Erstelle einen Spaltenvektor mit den Einträgen 1, 2, 3 
+'''
+
+
+'''
+c) Erstelle eine 2x3 Matrix
+'''
+
+'''
+d) Erstelle eine 6x6 Matrix mit nur 0-Wert Einträgen
+'''
+
+'''
+e) Erstelle eine 6x6 Matrix mit nur 1-Wert Einträgen
+'''
+
+''' 
+f) Erstelle eine 4x4 Einheitsmatrix 
+'''
+
+'''
+g) Ändere den Wert aus f) aus der zweiten Zeile und dritten Spalte zu dem Wert 5 
+'''
+
+'''
+h) Ändere alle Werte aus f) aus der zweiten Zeile zu dem Wert 4.5 
+'''
+
+'''
+i) Ändere die Werte aus f) aus der zweiten Zeile ab Spalte 3 zu dem Wert 3 
+'''
+
+'''
+j) Multipliziere, addiere, subtrahiere und dividiere die Matrizen a und b
+'''
+

0_Einführung/ü2/l_b.py

@@ -0,0 +1,102 @@
+"""
+ÜBUNG 1
+
+In dieser Übung soll der Umgang mit grundlegenden Matrix-Operationen mithilfe von numpy erlernt werden.
+
+"""
+
+import numpy as np
+
+'''
+a) Erstelle einen Zeilenvektor mit den Einträgen 1, 2, 3 
+'''
+A = [1, 2, 3]
+A = np.asarray(A)
+print("A", A)
+
+'''
+b) Erstelle einen Spaltenvektor mit den Einträgen 1, 2, 3 
+'''
+B = [[1], [2], [3]]
+B = np.asarray(B)
+print("B")
+print(B)
+
+B = [
+        [1],
+        [2],
+        [3]
+    ]
+B = np.asarray(B)
+print("B")
+print(B)
+
+'''
+c) Erstelle eine 2x3 Matrix
+'''
+C = [
+        [1, 2, 3],
+        [4, 5, 6]
+    ]
+C = np.asarray(C)
+print("C")
+print(C)
+
+
+'''
+d) Erstelle eine 6x6 Matrix mit nur 0-Wert Einträgen
+'''
+D = np.zeros(shape=(6, 6))
+print("D")
+print(D)
+
+'''
+e) Erstelle eine 6x6 Matrix mit nur 1-Wert Einträgen
+'''
+E = np.ones(shape=(6, 6))
+print("E")
+print(E)
+
+''' 
+f) Erstelle eine 4x4 Einheitsmatrix 
+'''
+F = np.eye(4)
+print("F")
+print(F)
+
+'''
+g) Ändere den Wert aus f) aus der zweiten Zeile und dritten Spalte zu dem Wert 5 
+'''
+F[1, 2] = 5
+print("G")
+print(F)
+
+'''
+h) Ändere alle Werte aus f) aus der zweiten Zeile zu dem Wert 4.5 
+'''
+F[1] = 4.5
+print("H")
+print(F)
+
+'''
+i) Ändere die Werte aus f) aus der zweiten Zeile ab Spalte 3 zu dem Wert 3 
+'''
+F[1, 2:4] = 3
+F[1, 2:] = 3
+print("I")
+print(F)
+
+'''
+j) Multipliziere, addiere, subtrahiere und dividiere die Matrizen a und b
+'''
+a = np.asarray([[1, 2], [3, 4]])
+b = np.asarray([[5, 6], [7, 8]])
+
+print("Elementweise Multiplikation")
+print(
+    a * b
+)
+print("Matrixoperation Multiplikation")
+print(np.matmul(a, b))
+print(a + b)
+print(a - b)

0_Einführung/ü3/README.md

@@ -0,0 +1,51 @@
+# OpenCV in Python
+Die beliebte Bildverarbeitungs-Software OpenCV existiert auch in Python. In dieser Übung sollen Sie einige Befehle
+erlernen, um grundlegende Funktionen mit OpenCV zu schreiben. 
+
+Um OpenCV zu nutzen, müssen Sie zuerst das Paker *cv2* installieren. Wenn Sie dieses Repository installiert haben,
+ist das bereits geschehen. Es wird für die folgenden Schritte davon ausgegangen, das *cv2* bereits installiert ist.
+Importieren Sie zu Beginn Ihres Skriptes das OpenCV Paket mit dem Befehl
+
+````python
+import cv2
+````
+
+Nun können Sie alle Funktionen von OpenCV mit dem vorangestellten Kürzel ``cv2.EIN_BEFEHL()`` nutzen.
+
+## Bild laden
+Bilder werden als MxN Matrizen (Grau- und Binärbilder) oder als MxNx3 Arrays (RGB-Farbbilder)
+gespeichert und interpretiert. Um ein Bild einzulesen, wird die Funktion ``cv2.imread(PFAD_ZUM_BID)`` aufgerufen
+und der Dateiname als Parameter in den Klammern übergeben.
+````python
+I = cv2.imread('myimage.bmp')  # Farbbild einlesen
+````
+Mit dem Befehl ``Ì.shape`` kann die Größe einer Matrix bestimmt werden.
+````python
+m, n, k = I.shape  # Größe ansehen
+````
+Bei einer Bildmatrix: Der erste Index ist der Zeilenindex (Bildkoordinaten: y-Achse), der zweite
+Index ist der Spaltenindex (Bildkoordinaten: x-Achse), wobei der Punkt (0,0) dem linken oberen
+Bildpunkt entspricht. Der dritte Index ist der Farbkanal.
+
+## Bild anzeigen
+Zum Anzeigen eines Bildes steht die Funktion ``cv2.imshow()`` zur Verfügung. Der Name des Fensters und die Bildvariable wird als
+Parameter übergeben. Ein neues Fenster öffnet sich und zeigt das Bild an.
+
+````python
+cv2.imshow("Fenstername", I)  #Bild anzeigen
+cv2.waitKey(0)  # Auf Tastendruck warten
+````
+Der Befehl ``cv2.waitKey(TIME)`` wird benötigt, damit das Programm auf eine Aktion des Benutzers wartet. Wenn der Parameter
+dabei 0 ist, wartet das Programm unendlich lange auf den nächsten Tastendruck des Nutzers.
+
+## Bild speichern
+Zum Abspeichern der Bilddaten steht die Funktion ``cv2.imwrite(SPEICHER_PFAD, BILD)`` zur Verfügung. Die Bildvariable wird
+als zweite Parameter und der Dateiname in Hochkommata als erster Parameter übergeben.
+````python
+cv2.imwrite('newimage.bmp', I)  # Bilddaten abpeichern
+````
+Wenn die Verzeichnisstruktur nicht angegeben wird, speichert Python die Datei im aktuellen
+Arbeitsverzeichnis.
+
+# Aufgabe a)
+Implementieren und testen Sie alle Funktion in einem neuen Skript [a.py](a.py)!

0_Einführung/ü4/README.md

@@ -0,0 +1,27 @@
+# Übung 4: Grundlagen
+
+Machen Sie sich mit den Grundlagen aus den vorherigen Übungen 1 vertraut. Diese Grundlagen werden nun praktisch angewandt
+Nutzen Sie für diese Übung keine Funktionen aus *OpenCV*!
+
+## Aufgabe a) 
+Führen Sie folgende Aufgabenschritte durch:
+
+1. Erstellen Sie eine 10x10-Matrix mit den Werten von 0 bis 99 wie folgt:
+<p align="center">
+<img src="https://latex.codecogs.com/svg.image?M&space;=&space;\begin{bmatrix}&space;0&&space;&space;1&&space;\ldots&space;&&space;&space;8&&space;9&space;\\&space;10&&space;&space;11&&space;&space;&&space;&space;18&&space;&space;19\\&space;\vdots&space;&&space;\vdots&space;&space;&&space;\ddots&space;&space;&&space;\vdots&space;&space;&&space;\vdots&space;&space;\\&space;80&&space;&space;81&&space;\ldots&space;&&space;88&space;&&space;89&space;\\&space;90&&space;91&space;&&space;\ldots&space;&&space;98&space;&&space;99&space;\\\end{bmatrix}&space;" title="M = \begin{bmatrix} 0& 1& \ldots & 8& 9 \\ 10& 11& & 18& 19\\ \vdots & \vdots & \ddots & \vdots & \vdots \\ 80& 81& \ldots & 88 & 89 \\ 90& 91 & \ldots & 98 & 99 \\\end{bmatrix} " />
+</p>
+
+2. Erzeugen Sie einen Zeilenvektor der Dimension 10. Alle Komponenten sollen den Wert 20 haben:
+
+<p align="center">
+<img src="https://latex.codecogs.com/svg.image?v&space;=&space;\begin{bmatrix}&space;20&&space;&space;20&&space;20&&space;20&&space;20&&space;20&&space;20&&space;20&&space;20&&space;20&space;\\\end{bmatrix}" title="v = \begin{bmatrix} 20& 20& 20& 20& 20& 20& 20& 20& 20& 20 \\\end{bmatrix}" />
+</p>
+
+3. Subtrahieren Sie die zweite Zeile der Matrix M vom eben erzeugten Vektor v.
+4. Multiplizieren Sie den resultierenden Vektor vr als Spaltenvektor von rechts mit der Matrix M
+5. Teilen Sie die Komponenten des entstandenen Vektors jeweils durch 100 und runden Sie das Ergebnis. 
+6. Berechnen Sie das Maximum
+
+Wie lautet das Ergebnis?
+
+Die Musterlösung findet sich in [l_a.py](l_a.py)

0_Einführung/ü4/l_a.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+M = np.zeros((10, 10))
+for i in range(10):
+    for j in range(10):
+        M[i, j] = 10 * i + j
+
+print("(1) M=", M)
+
+v = np.ones((1, 10)) * 20
+print("(2) v=", v)
+
+vr = v - M[1, :]
+print("(3) vr:", vr)
+
+res = np.matmul(M, np.transpose(vr, axes=(1, 0)))
+print("(4) res:", res)
+
+res = res / 100
+res = np.round(res)  # np.floor() np.ceil()
+print("(5) res:", res)
+
+maximum = np.max(res)
+print("(6) maximum:", maximum)