2018-12-19-155957.ipynb

Kernel: SageMath (stable)

Aufgabe 1a

Es gibt folgende Koordinatenarten aus Sicht der Grafikpipeline laut VL:

1. Objektkoordinaten

2. Weltkoordinaten

3. Projektionskoordinaten

4. Normierte Koordinaten

5. Bildschirmkoordinaten

Für folgende Koordinatenarten erklären wir nun die Verwendung:

Objektkoordinaten

Objektkoordinaten beschreiben die Lage von (3D-)Objekten lokal aus der Sicht eines bestimmten Objekts/Punkts $p$ innerhalb der Gesamtwelt. $p$ wird damit zum Ursprung des Systems der Objektkoordinaten.

Objektkoordinaten sind z.B. nützlich bei der Modellierung von Mehrgelenkigen Armen, sodass Bewegungen von starren Abschnitten jeweils aus der Sicht des zuständigen Gelenks beschrieben werden können.

Bildschirmkoordinaten

Um eine 3D Szene dem Nutzer zugänglich zu machen, muss sie letztendlich in einem Fenster auf einem Bildschirm angezeigt werden. Hierzu werden (projizierten) Punkten sichtbarer Objekte Bildschirmkoordinaten zugewiesen, sodass sie an die Größe und Position des Anzeigefensters angepasst auf dem Bildschirm dargestellt werden können.

Bildschirmkoordinaten kommen auch im umgekehrten Sinne zum Einsatz: Wählt der Nutzer mit der Maus ein Objekt der Szene aus, so müssen die Bildschirmkoordinaten des Mauszeigers in z.B. Weltkoordinaten der angezeigten Szene übersetzt werden.

Aufgabe 1b

Ein 2D Eingabegerät (z.B. Maus) erlaubt es dem Nutzer bei der Interaktion nicht, auch eine Tiefenposition anzugeben. Beispielsweise könnte er ein 3D Objekt mit der Maus greifen und verschieben wollen (Dragging), allerdings ist beim Verschieben nicht klar, ob das Objekt z. B. lediglich in der x-y-Ebene, oder nach hinten in die z-Ebene verschoben werden soll.

2D-Interaktionen mit 3D-Darstellungen sind also mehrdeutig.

Behebungsmöglichkeit: Manipulatoren

Manipulatoren repräsentieren mögliche Operationen auf Objekten (und/oder ihren Status) in der Szene visuell. Das Eingabeproblem lässt sich mit ihnen also z.B. folgendermaßen lösen:

Wird ein Objekt ausgewählt, erscheinen sog. "Handles", also grafische Elemente, die z.B. je einer Verschiebungsrichtung zugeordnet sind. Wird nun Dragging auf den Handles ausgeführt, so ist die Richtung der Verschiebung eindeutig bestimmt.

Behebungsmöglichkeit: Direktes 2D-Maus-Mapping

Jedem 3D Objekt der Szene werden in der Nähe 2D Bereiche in Bildschirmkoordinaten zugeordnet, für jeweils positive/negative Manipulation in Richtung einer der 3D-Achsen.

Beispielsweise kann der Bildschirmbereich rechts-unten von einem Objekt negativem y-Achsenbereich und links-oben positivem y-Achsenbereich zugeordnet werden. Zieht der Nutzer nun beim Dragging das Objekt z.B. in Richtung des Bereichs rechts unten auf dem Bildschirm, so wird entsprechend die y-Position des Objekts in negative Richtung verändert.

Aufgabe 2a

Bei perspektivischer Projektion laufen die Projektionsstrahlen der Punkte eines Objekts in einem zentralen Punkt des Betrachters (Augpunkt), dem "Projektionszentrum", zusammen.

Bei paralleler Projektion hingegen verlaufen jene Strahlen immer parallel zu einander.

Aufgabe 2b

Parallele Projektion erscheint zwar weniger realistisch, da sie nicht an das menschliche Sehempfinden angepasst ist, dafür bleiben allerdings Winkel im Allgemeinen erhalten und parallele Geraden der projizierten Szene bleiben parallel.

Somit eignet sich parallele Projektion für Anwendungsgebiete, welche exakte Darstellungen erfordern, wie beispielsweise in der Medizin. Perspektivische Verzerrung kann hier schwere Folgen haben, wenn z. B. generierte Bilder als Grundlage für Operationen verwendet werden.

Aufgabe 3a

from IPython.display import Math

r_s = var('r_s')
alpha = var('alpha')

T_a = matrix([
    [1, 0, 0, r_s * cos(alpha)],
    [0, 1, 0, r_s * sin(alpha)],
    [0, 0, 1, 0],
    [0, 0, 0, 1]
])

Rendering3a = r'T_a = ' + latex(T_a)
Math(Rendering3a)

$$T_a = \left(\begin{array}{rrrr} 1 & 0 & 0 & r_{s} \cos\left(\alpha\right) \\ 0 & 1 & 0 & r_{s} \sin\left(\alpha\right) \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Aufgabe 3b

Eine Drehung um 23° mathematisch negativ um die y-Achse sollte einer Drehung von 360°-23°=337° positiv entsprechen, dies wird durch folgende Matrix $R_y$ erreicht:

deg = var('deg')
degConv = {deg: pi/180}

beta = var('beta')
betaConv = {beta: 23}

R_y = matrix([
        [cos((360-beta)*deg), 0, sin((360-beta)*deg), 0],
        [0, 1, 0, 0],
        [-sin((360-beta)*deg), 0, cos((360-beta)*deg), 0],
        [0, 0, 0, 1]
    ])
R_yResolved = R_y.subs(betaConv)

Rendering3b1 = r'R_y = ' + latex(R_y) + r' = ' + latex(R_yResolved)
Math(Rendering3b1)

$$R_y = \left(\begin{array}{rrrr} \cos\left(-{\left(\beta - 360\right)} \mathit{deg}\right) & 0 & \sin\left(-{\left(\beta - 360\right)} \mathit{deg}\right) & 0 \\ 0 & 1 & 0 & 0 \\ -\sin\left(-{\left(\beta - 360\right)} \mathit{deg}\right) & 0 & \cos\left(-{\left(\beta - 360\right)} \mathit{deg}\right) & 0 \\ 0 & 0 & 0 & 1 \end{array}\right) = \left(\begin{array}{rrrr} \cos\left(337 \, \mathit{deg}\right) & 0 & \sin\left(337 \, \mathit{deg}\right) & 0 \\ 0 & 1 & 0 & 0 \\ -\sin\left(337 \, \mathit{deg}\right) & 0 & \cos\left(337 \, \mathit{deg}\right) & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Um also Punkte im Planetenkoordinatensystem in das Weltkoordinatensystem zu übersetzen, simulieren wir eine um 23° um y gedrehte z-Achse, indem wir alle Punkte mittels $R_y$ um 23° um die y-Achse drehen und dann mittels $T_a$ an die Stelle des Planeten verschieben:

T_b = T_a * R_y
T_bResolved = T_b.subs(betaConv)
Rendering3b2 = r'T_b = T_a \cdot R_y = ' + latex(T_bResolved)
Math(Rendering3b2)

$$T_b = T_a \cdot R_y = \left(\begin{array}{rrrr} \cos\left(337 \, \mathit{deg}\right) & 0 & \sin\left(337 \, \mathit{deg}\right) & r_{s} \cos\left(\alpha\right) \\ 0 & 1 & 0 & r_{s} \sin\left(\alpha\right) \\ -\sin\left(337 \, \mathit{deg}\right) & 0 & \cos\left(337 \, \mathit{deg}\right) & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Aufgabe 3c

Eine Drehung um 90° um die Planetenachse (w-Achse, z-Achse im Standardsystem) wird durch diese Matrix durchgeführt:

R_z = matrix([
        [0, -1, 0, 0],
        [1, 0, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ])

Rendering3c1 = r'R_z = ' + latex(R_z)
Math(Rendering3c1)

$$R_z = \left(\begin{array}{rrrr} 0 & -1 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Wir drehen also zunächst die Punkte im Planetensystem um dessen Achse (mit $R_z$), dann drehen wir um die y-Achse, so als ob wir die Planetenachse um 23° kippen (mit $R_y$). Zuletzt müssen wir die Punkte an die Stelle des Planeten mit $T_a$ verschieben.

Somit gilt für $T_c$:

T_c = T_a * R_y * R_z
T_cResolved = T_c.subs(betaConv)

Rendering3c2 = r'T_c = T_a \cdot R_y \cdot R_z = ' + latex(T_cResolved)
Math(Rendering3c2)

$$T_c = T_a \cdot R_y \cdot R_z = \left(\begin{array}{rrrr} 0 & -\cos\left(337 \, \mathit{deg}\right) & \sin\left(337 \, \mathit{deg}\right) & r_{s} \cos\left(\alpha\right) \\ 1 & 0 & 0 & r_{s} \sin\left(\alpha\right) \\ 0 & \sin\left(337 \, \mathit{deg}\right) & \cos\left(337 \, \mathit{deg}\right) & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Aufgabe 3d

r_p = var('r_p')
P_N = matrix([[0], [0], [r_p], [1]])
P = matrix([[100], [200], [300], [1]])

Rendering3d1 = r'T_c \cdot P_N = ' + latex(T_c * P_N)
Rendering3d2 = r'T_c \cdot P = ' + latex(T_c * P)
Math(Rendering3d1)

$$T_c \cdot P_N = \left(\begin{array}{r} r_{s} \cos\left(\alpha\right) + r_{p} \sin\left(-{\left(\beta - 360\right)} \mathit{deg}\right) \\ r_{s} \sin\left(\alpha\right) \\ r_{p} \cos\left(-{\left(\beta - 360\right)} \mathit{deg}\right) \\ 1 \end{array}\right)$$

Math(Rendering3d2)

$$T_c \cdot P = \left(\begin{array}{r} r_{s} \cos\left(\alpha\right) - 200 \, \cos\left(-{\left(\beta - 360\right)} \mathit{deg}\right) + 300 \, \sin\left(-{\left(\beta - 360\right)} \mathit{deg}\right) \\ r_{s} \sin\left(\alpha\right) + 100 \\ 300 \, \cos\left(-{\left(\beta - 360\right)} \mathit{deg}\right) + 200 \, \sin\left(-{\left(\beta - 360\right)} \mathit{deg}\right) \\ 1 \end{array}\right)$$

Aufgabe 3e

Sollte tatsächlich eine Stauchung im Sinne von Verkleinerung gemeint sein, dann wird um den Faktor $s^{-1}$ skaliert und die Matrix lautet:

def M(s):
  return matrix([
      [s, 0, 0, 0],
      [0, s, 0, 0],
      [0, 0, s, 0],
      [0, 0, 0, 1]
  ])

s=149597870700

Math(latex(M(s^(-1))))

$$\left(\begin{array}{rrrr} \frac{1}{149597870700} & 0 & 0 & 0 \\ 0 & \frac{1}{149597870700} & 0 & 0 \\ 0 & 0 & \frac{1}{149597870700} & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$

Ist eine Vergrößerung um den Maßstab gemeint, dann lautet sie hingegen:

Math(latex(M(s)))

$$\left(\begin{array}{rrrr} 149597870700 & 0 & 0 & 0 \\ 0 & 149597870700 & 0 & 0 \\ 0 & 0 & 149597870700 & 0 \\ 0 & 0 & 0 & 1 \end{array}\right)$$