# Ein Vektor ist in Python im Prinzip ein 1D-Array
a_vector = np.array([2, 3, -1])

# Zwei Vektoren lassen sich recht einfach addieren und subtrahieren
another_vector = np.array([4, -2, 1])

print("Die Summe: ", a_vector + another_vector)

print("Die Differenz: ", a_vector - another_vector)

print("Das punktweise Produkt: ", a_vector * another_vector)

print("Der punktweise Quotient: ", a_vector / another_vector)

print("Punktweises Potenzieren: ", a_vector.astype(float) ** another_vector)

# bastel-Variante für das Skalarprodukt
print(np.sum(a_vector * another_vector))

# built-in-Variante für das Skalarprodukt
print(np.dot(a_vector, another_vector))

# built-in-Variante für das Kreuzprodukt
print(np.cross(a_vector, another_vector))

# definiere eine Matrix
a_matrix = np.array([[2, 3, 5, -3], [1, 3, -1, 4], [1, 2, -3, 2], [3, 4, -2, 1]])
a_matrix

# verschiedene Slices/Teile
print("Erste Zeile: ", a_matrix[0, :])

print("Erste Spalte: ", a_matrix[:, 0])

print("Letzte Zeile: ", a_matrix[-1, :])

print("Letzte Spalte: ", a_matrix[:, -1])

print("Element links oben: ", a_matrix[0, 0])

print("Element an bestimmter Position: ", a_matrix[2, 3])

print("Elemente im Viereck innen: \n", a_matrix[1:3, 1:3])

print("Jedes 2. Element der 2. Zeile: ", a_matrix[1, ::2])

print("Dritte Spalte, von unten nach oben: ", a_matrix[::-1, 2])

# transponierte Matrix
np.transpose(a_matrix)

# Elemente verändern
a_changed_matrix = a_matrix

a_changed_matrix[0, 1] = -4
second_row = a_changed_matrix[1]

print("Matrix geändert auf \n", a_changed_matrix)
print("Die zweite Zeile: ", second_row)

# ein Element an bestimmter Stelle in bestimmter Richtung herauslöschen
a_changed_matrix = np.delete(a_changed_matrix, 1, axis=0)

print("Zweite Zeile wurde gelöscht: \n", a_changed_matrix)

# Die gelöschte Zeile wieder einfügen
a_changed_matrix = np.insert(a_changed_matrix, 1, second_row, axis=0)

print("Zweite Zeile wieder eingefügt: \n", a_changed_matrix)

# eine Zeile anhängen
a_changed_matrix = np.append(a_changed_matrix, [second_row], axis=0)

print("Zweite Zeile nochmal angehängt: \n", a_changed_matrix)

# zwei Arrays kombinieren
a_changed_matrix = np.concatenate((a_changed_matrix, a_changed_matrix), axis=1) # versuche auch axis=0

print("Die veränderte Matrix, kombiniert mit sich selbst: \n", a_changed_matrix)

# und, wichtig: Die Dimensionen der Matrix verändern (also das Array verformen)
a_changed_matrix = np.reshape(a_changed_matrix, (2, -1))

print("zwei Zeilen und wie viele Spalten? \n", a_changed_matrix)

# zwei Matrizen miteinander multiplizieren
a_matrix_squared = np.matmul(a_matrix, a_matrix)
a_matrix_squared

# Ein paar Dinge aus der Linearen Algebra

print("Rang der Matrix ", np.linalg.matrix_rank(a_matrix))

print("Determinante der Matrix ", np.linalg.det(a_matrix))

print("Eigensystem der Matrix: ")
print("Eigenwerte der Matrix: ", np.linalg.eig(a_matrix)[0])
print("Eigenvektoren der Matrix: \n", np.linalg.eig(a_matrix)[1])

# generieren wir erst einmal Daten
x_values = np.linspace(0, 10, 200)
fake_data = 0.5 * x_values + np.random.normal(size=len(x_values))

fig = plt.figure()

plt.scatter(x_values, fake_data, c="r", marker="x")

plt.show()

# Konstuiere y und X
y_vec = fake_data

# für die Matrix X werden x-Werte und Einsen "nebeneinander" geschrieben
x_mat = np.hstack((x_values.reshape((len(x_values),1)), np.ones((len(x_values),1))))

# berechne a nach der Formel. Das "@" ist eine Kurzschreibweise für Matrixmultiplikation
a_vec = np.matmul(np.linalg.pinv(np.transpose(x_mat) @ x_mat), np.transpose(x_mat) @ y_vec)

# die Lösung ist ein Vektor aus a_1 und a_0
print("Die fit-Koeffizienten: ", a_vec)

# Erzeuge die Fit-Gerade als Einsetzen der x-Werte in ein Polynom mit den Koeffizienten a_1 und a_0
reg_data = np.polyval(a_vec, x_values)

# neue Figur
fig = plt.figure()

# plotte wieder die Daten
plt.scatter(x_values, fake_data, c="r", marker="x")

# und dazu die Gerade
plt.plot(x_values, reg_data, "b", label="Linear fit")

# die Legende
plt.legend(loc=0)

plt.show()

# lade ein Bild über matplotlib-Bibliothek "image"
# os.path.join zum OS-unabhängigen aneinanderfügen von Dateipfaden
the_picture = image.imread(os.path.join('data', 'pinky.jpg'))

# schauen wir uns das Bild an
plt.figure()

# der Befehl für die Darstellung eines Bildes
plt.imshow(the_picture)

plt.show()

# eigentlich ist das Bild aber "nur" ein Array, wie oben beschrieben
the_picture

# Die Dimension des Arrays:
np.shape(the_picture)

# Wir können diese Werte auch so normieren, dass sie zwischen 0 und 1 liegen:
the_picture_normalized = the_picture/256


# jetzt können wir mit "matshow" statt "imshow" weitermachen
plt.matshow(the_picture_normalized)

# gespiegelt, rechts-links

# Slicen aller Indices der Dimension 1 in umgekehrter Reihenfolge
plt.matshow(the_picture_normalized[:,::-1,:])

plt.show()

# schwarz-weiß

# Hier brauchen wir eine Definition, wie man aus 
# RGB-Werten (also den drei Farbkanälen) einen
# Grayscale-Kanal macht. Die einfachste Möglichkeit dafür
# ist ein arithmetisches Mittel:
the_picture_normalized_bw = np.mean(the_picture_normalized, axis=2)

# danach hat das Array eine Dimension verloren und sieht seltsam aus
print(np.shape(the_picture_normalized_bw))

# deshalb müssen wir spezifisch eine Colormap (cmap) angeben
# die richtige für grayscale ist "gray" (siehe unten), aber es gibt
# viele teils lustige Möglichgkeiten: Greys, spring, magma, PRGn, seismic, hsv, Set2, prism
plt.matshow(the_picture_normalized_bw, cmap="gray") 

plt.show()

# Nur ein Farbkanal

# Hier suchen wir uns also einen Kanal aus, z.B. R
the_picture_normalized_one_channel = the_picture_normalized[:,:,0]

# danach hat das Array wieder eine Dimension verloren
print(np.shape(the_picture_normalized_one_channel))

# deshalb müssen wir wieder eine Colormap (cmap) angeben
# die spezifischen hier sind "Reds", "Greens" und "Blues"
plt.matshow(the_picture_normalized_one_channel, cmap="Reds") 

plt.show()

# Alle drei Farbkanäle nebeneinander
plt.figure(figsize=(10, 5))

# Definiere alle nötigen Colormaps in einer Liste
colormaps = ["Reds", "Greens", "Blues"]

# Loop über den index der drei Farbkanäle
for ind_color in range(3):
    ax = plt.subplot(1, 3, ind_color+1)
    ax.matshow(the_picture_normalized[:,:,ind_color], cmap=colormaps[ind_color]) 

plt.show()

# Aufhellen
plt.figure(figsize=(10, 5))

# normales Bild zum Vergleich
ax = plt.subplot(1, 2, 1)
ax.matshow(the_picture_normalized) 

# aufgehelltes Bild daneben
ax = plt.subplot(1, 2, 2)
# eine einfache Methode, Zahlen zwischen 0 und 1 größer zu machen
# ist, die Quadratwurzel zu ziehen
ax.matshow(np.sqrt(the_picture_normalized)) 

plt.show()