Grafikprogrammierung
3D Transformationen

Das Weiterschalten der Folien kann ebenfalls durch das Klicken auf den rechten bzw. linken Folienrand erfolgen.

• Um 3D Objekttransformationen zu realisieren, können wir die gleichen Hilfsmittel anwenden wie im 2D Fall, nämlich lineare Abbildungen und homogene Koordinaten
• Im Prinzip müssen die Koordinaten "nur" um eine z-Koordinate erweitert werden
• Transformationen im 3D-Raum sind jedoch im Detail schon komplizierter als im 2D, da sie mehr Parameter haben
• Besonders die Beschreibung einer Rotation wird schwieriger, da nun drei statt nur einer Achse existieren, um die rotiert werden kann

x

y

z

x

y

z

Linkshändiges Koordinatensystem

Rechtshändiges Koordinatensystem

• Linkshändige Koordinatensysteme werden relativ selten eingesetzt. In dieser Vorlesung werden ausschließlich rechtshändige Koordinatensysteme verwendet.
• OpenGL verwendet ebenfalls ein rechtshändiges Koordinatensystem: $x$ zeigt nach rechts, $y$ nach oben, und $z$ aus dem Bildschirm heraus

• Eine Veränderung der Größe eines Objekts kann durch eine Skalierung erreicht werden
• Eine ungleichförmige Skalierung in alle drei Raumrichtungen $s_x, s_y, s_z$ wird erreicht durch:
  $\underline{\tilde{\mathbf{P}}} = \begin{pmatrix} \tilde{x} \\ \tilde{y} \\ \tilde{z} \\ 1 \end{pmatrix} = \begin{bmatrix}s_x & 0& 0 & 0\\ 0 & s_y & 0 & 0 \\ 0 & 0 & s_z & 0 \\ 0 & 0 & 0 &1\end{bmatrix} \begin{pmatrix} x \\ y \\ z \\ 1 \end{pmatrix} = \mathtt{T}_s \, \underline{\mathbf{P}}$

• Im 2D Fall wurde stets um den Koordinatenursprung gedreht. Im 3D Raum gibt es die $x$-, $y$- und $z$-Achse, um die gedreht werden kann
• Dabei entspricht die Rotation um die $z$-Achse exakt einer 2D Rotation, da nur die $x$- und $y$-Koordinaten eines Punktes verändert werden
• Rotation um die $z$-Achse um den Winkel $\alpha$:
  $\underline{\tilde{\mathbf{P}}} = \begin{bmatrix}\cos \alpha & -\sin \alpha& 0 & 0\\ \sin \alpha & \cos \alpha & 0 & 0\\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 &1\end{bmatrix} \begin{pmatrix} x \\ y \\ z \\ 1 \end{pmatrix} = \mathtt{T}_{r_z} \, \underline{\mathbf{P}}$

• Rotation um die $x$-Achse um den Winkel $\alpha$:
  $\underline{\tilde{\mathbf{P}}} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0& \cos \alpha & -\sin \alpha& 0 \\ 0 & \sin \alpha & \cos \alpha & 0 \\ 0 & 0 & 0 &1 \\ \end{bmatrix} \begin{pmatrix} x \\ y \\ z \\ 1 \end{pmatrix} = \mathtt{T}_{r_x} \, \underline{\mathbf{P}}$
• Rotation um die $y$-Achse um den Winkel $\alpha$:
  $\underline{\tilde{\mathbf{P}}} = \begin{bmatrix} \cos \alpha & 0& \sin \alpha& 0 \\ 0 & 1 & 0 & 0 \\ -\sin \alpha & 0 &\cos \alpha & 0 \\ 0 & 0 & 0 &1 \\ \end{bmatrix} \begin{pmatrix} x \\ y \\ z \\ 1 \end{pmatrix} = \mathtt{T}_{r_y} \, \underline{\mathbf{P}}$

• Die $4 \times 4$ Transformationsmatrizen für homogene Punkte werden in OpenGL als ein Float-Array repräsentiert

  GLfloat T[16];

• Dabei werden die Matrixelemente spaltenweise abgelegt:
  $\mathtt{T} = \begin{bmatrix} t_0 & t_4 & t_8 & t_{12} \\ t_1 & t_5 & t_9 & t_{13} \\ t_2 & t_6 & t_{10} & t_{14} \\ t_3 & t_7 & t_{11} & t_{15} \end{bmatrix}$
  Achtung: zeilenweise ist eigentlich üblicher!

• Für die Transformation von Objekten ist die GL_MODELVIEW Matrix verantwortlich.
• Die Manipulation dieser Matrix wird aktiviert durch

  glMatrixMode(GL_MODELVIEW);

• Alle Funktionen zur Matrixmanipulation, wie glLoadIdentity, glLoadMatrix, glMultMatrix glRotate, glScale, glTranslate, glPushMatrix, glPopMatrix werden dann auf der GL_MODELVIEW Matrix ausgeführt.
• Der aktuelle Zustand der GL_MODELVIEW Matrix beeinflusst die Transformation der Objekte nur dann, wenn diese gezeichnet werden (OpenGL als Zustandsmaschine)

$x$

$y$

$z$

• Die Transformation $\underline{\tilde{\mathbf{P}}} = \mathtt{T}_{r_z} \mathtt{T}_{r_y} \mathtt{T}_{r_x} \, \underline{\mathbf{P}}$ kann jedoch auch anderes interpretiert werden, wenn die Rotationsachsen nicht statisch sind, sondern mit rotiert werden
• Bei mitdrehenden Achsen kann die Formel von links nach rechts interpretiert werden: Rotation zunächst um die $z$-Achse, dann um die mitgedrehte $y$-Achse und letztendlich um die mitgedrehte $x$-Achse
  
• Diese Reihenfolge und Denkweise ist z.B. in der Luftfahrt gebräuchlich. Das Bezugssystem ist das Flugzeug, welches sich immer mitdreht: 1. gieren (um $z$), 2. nicken (um mitgedrehtes $y$), 3. rollen (um mitgedrehtes $x$)

• Da sich die Achsen mitdrehen, kann es auch Sinn machen, mehrfach um die gleiche (mitgedrehte) Achse zu rotieren.
• Eine beliebte Kombination ist die sogenannte "$x$-Konvention" (auch "313-Konvention" genannt):
  $\underline{\tilde{\mathbf{P}}} = \mathtt{T}_{r_z} \mathtt{T}_{r_x} \mathtt{T}_{r_z} \, \underline{\mathbf{P}}$
• Achtung: Wird für dieses Beispiel bei $\mathtt{T}_{r_x}$ um $\alpha = 0$ oder $180$ Grad gedreht, sind erste und letzte Drehachse parallel und ein Freiheitsgrad fällt weg
• Dies wird "Gimbal Lock" genannt und ist ein allgemeines Problem von Eulerwinkeln (nicht nur bei der 313-Konvention). Ein Gimbal Lock führte z.B. zu Problemen bei der Apollo 11 Mission

• Quelltext des Beispiels mit GLUT: GimbalLock.cpp
• Quelltext des Beispiels mit Qt: GimbalLock.cpp
• Quelltext des Beispiels mit Java: GimbalLock.java
• 3D Vertex-Daten des Flugzeugs: ToyPlaneData.txt

• Die Basisvektoren $\tilde{\mathbf{b}}_x, \tilde{\mathbf{b}}_y, \tilde{\mathbf{b}}_z$ sind orthonormal
• Rotationsmatrizen sind leicht invertierbar durch Transponieren der Matrix
  $\mathtt{R}^{-1} = \mathtt{R}^\top$
• Damit gilt auch
  $\mathtt{R}^{-1} \mathtt{R}= \mathtt{R}^\top \mathtt{R} = \mathtt{I}_{3 \times 3}$
• Rotationen sind nicht kommutativ, d.h. im Allgemeinen gilt
  $\mathtt{R}_a \mathtt{R}_b \ne \mathtt{R}_b \mathtt{R}_a$

• Eulerwinkel sind leicht zu implementieren und zu verstehen
• Allerdings gibt es Unstetigkeiten und es kann zu einem Gimbal Lock kommen
• Ein weiterer Nachteil ist, dass es relativ schwer ist, von einer gegebenen Rotationsmatrix die erzeugenden Eulerwinkel auszurechnen (typischerweise nicht eindeutig)
• Abhilfe schaffen sogenannte Quaternionen

mit $\mathbf{v}_n = (\mathbf{v}^\top \mathbf{n})\, \mathbf{n} = (\mathbf{n}^\top \mathbf{v} )\, \mathbf{n} = (\mathbf{n} \mathbf{n}^\top) \mathbf{v}$ gilt:

$\begin{align} \tilde{\mathbf{v}} &= \mathbf{v}_n + (\mathbf{v} - \mathbf{v}_n) \cos \alpha + (\mathbf{n} \times \mathbf{v}) \sin \alpha\\ \tilde{\mathbf{v}} &= (\mathbf{n} \mathbf{n}^\top) \mathbf{v} + (\mathbf{v} - (\mathbf{n}\mathbf{n}^\top ) \mathbf{v}) \cos \alpha + ([\mathbf{n}]_\times \mathbf{v}) \sin \alpha\\ \tilde{\mathbf{v}} &= \mathtt{R} \mathbf{v} \end{align}$

wobei die resultierende $3 \times 3$ Rotationsmatrix eine Funktion von $\mathbf{n}$ und $\alpha$ ist, die sich berechnen lässt durch
$ \mathtt{R} = (\mathbf{n} \mathbf{n}^\top) + (\cos \alpha) (\mathbf{I}_{3\times 3} - (\mathbf{n} \mathbf{n}^\top)) + (\sin \alpha) [\mathbf{n}]_\times$

Die Rotationsmatrix hat also 4 Freiheitsgrade $\mathbf{n}=(n_x, n_y, n_z)$ und $\alpha$. Beziehungsweise, da gilt $|\mathbf{n}|=1$, gibt es eigentlich nur 3 Freiheitsgrade (äquivalent der Repräsentation mit Eulerwinkeln)

• Wichtiger Begründer der Theorie: William Rowan Hamilton (seit 1843)
• Ein Quaternion $\mathbf{q}$ besteht aus 4 Komponenten
• Die Komponenten werden meist in ein Skalar $s$ und einen Vektor $\mathbf{v}=(v_x, v_y, v_y)^\top$ aufgeteilt:

  $\mathbf{q} = \begin{pmatrix}q_1\\q_2\\ q_3\\ q_4\end{pmatrix} = \begin{pmatrix}s \\v_x \\ v_y \\ v_z\end{pmatrix} = (s, \mathbf{v}^\top)^\top$

• Im Folgenden werden immer normierte Quaternionen verwendet, d.h. $|\mathbf{q}| = 1$ (wieder 3 Freiheitsgrade)

• Quaternionen können zur Repräsentation von Rotationen verwendet werden
• Zur Darstellung einer Rotation um eine beliebige gegebene Achse $\mathbf{n}$ (mit $|\mathbf{n}|=1$) um einen Winkel $\alpha$ gilt:
  $\mathbf{q} = \begin{pmatrix}s\\v_x\\ v_y\\ v_z\end{pmatrix} = \begin{pmatrix}\cos \frac{\alpha}{2} \\n_x \sin \frac{\alpha}{2} \\ n_y \sin \frac{\alpha}{2} \\ n_z \sin \frac{\alpha}{2} \end{pmatrix} = (\cos \frac{\alpha}{2}, (\sin \frac{\alpha}{2}) \mathbf{n}^\top)^\top$

• Für die Multiplikation von Quaternionen gilt:
  $\begin{align}\mathbf{q} \mathbf{q}' &= \begin{pmatrix} s\, s'- v_x v'_x - v_y v'_y-v_z v'_z \\ s v'_x + v_x s' + v_y v'_z - v_z v'_y\\ s v'_y + v_y s' + v_z v'_x - v_x v'_z\\ s v'_z + v_z s' + v_x v'_y - v_y v'_x\end{pmatrix}\\ &=(s \, s'- \mathbf{v}^\top \mathbf{v}' , (s \mathbf{v}' + s'\mathbf{v}+ \mathbf{v} \times \mathbf{v}')^\top )^\top \end{align}$
• Genau wie die Multiplikation von Matrizen, ist die Quaternionen-Multiplikation nicht kommutativ
• Die Quaternionen-Multiplikation kann zur Verkettung von Rotationen verwendet werden (entsprechend der Matrix-Multiplikation bei Rotationsmatrizen)

• Durch weitere Umformungen und geschicktes Vorberechnen mehrfach benötigter Ausdrücke kann die Quaternionen-Multiplikation sehr effizient implementiert werden:

Quaternion fastmul(Quaternion ql, Quaternion qr) {
double s[9], t;
s[0] = (ql.vz-ql.vy)*(qr.vy-qr.vz); s[1] = (ql.s +ql.vx)*(qr.s +qr.vx);
s[2] = (ql.s -ql.vx)*(qr.vy+qr.vz); s[3] = (ql.vz+ql.vy)*(qr.s -qr.vx);
s[4] = (ql.vz-ql.vx)*(qr.vx-qr.vy); s[5] = (ql.vz+ql.vx)*(qr.vx+qr.vy);
s[6] = (ql.s +ql.vy)*(qr.s -qr.vz); s[7] = (ql.s -ql.vy)*(qr.s +qr.vz);
s[8] = s[5]+s[6]+s[7];
t = (s[4]+s[8])*0.5;
return Quaternion(s[0]+t-s[5], s[1]+t-s[8], s[2]+t-s[7], s[3]+t-s[6]);
} 

• Eine Inversion kann durch die Konjugation des Quaternions erfolgen:
  $\mathbf{q}^{-1} = (s, -\mathbf{v}^\top)^\top$
• Das neutrale Element bezüglich der Quaternionen-Multiplikation ist:
  $\mathbf{1} = (1, \mathbf{0}^\top)^\top$

• Ein Punkt $\mathbf{p}$, der mit einem Quaternion rotiert werden soll, muss zunächst ebenfalls als Quaternionen dargestellt werden:
  $\mathbf{p} = \begin{pmatrix}x \\ y \\ z \end{pmatrix} \rightarrow \mathbf{p}_q = \begin{pmatrix}0 \\ x \\ y \\ z \end{pmatrix}$
• Dann gilt für den transformierten Punkt $\tilde{\mathbf{p}}_q$:
  $\tilde{\mathbf{p}}_q = \mathbf{q}\, \mathbf{p}_q \,\mathbf{q}^{-1} $

• Ein Quaternion $\mathbf{q}= (s, x, y, z)^\top$ kann in eine Rotationsmatrix $\mathtt{R}$ konvertiert werden:
  $\begin{bmatrix} 1-2y^2-2z^2 & 2xy-2sz& 2xz+2ys \\ 2xy+2sz & 1-2x^2-2z^2& 2yz-2sx \\ 2xz-2sy & 2yz+2sx& 1-2x^2-2y^2 \\ \end{bmatrix} $

• gesucht: Rotation, die den Einheitsvektor $\mathbf{b}$ auf den Einheitsvektor $\tilde{\mathbf{b}}$ dreht
• Lösung:
  • Bestimmen der Rotationsachse mit dem Kreuzprodukt: $\mathbf{n}= \mathbf{b} \times \tilde{\mathbf{b}}$
  • Bestimmen des Rotationswinkels $\alpha$ mit dem Skalarprodukt: $\mathbf{b}^\top \tilde{\mathbf{b}}=\cos \alpha$
  • Das Quaternion $\mathbf{q} = (\cos \frac{\alpha}{2}, (\sin \frac{\alpha}{2}) \mathbf{n}^\top)^\top$ beschreibt die gesuchte Rotation

• Gesucht: Position des Punktes $\mathbf{p}=(x,y,z)^\top$ nach einer Rotation um die Achse $\mathbf{n}$ mit dem Winkel $\alpha$
• Lösung:
  • Rotationsquaternion bestimmen: $\mathbf{q} = (\cos \frac{\alpha}{2}, (\sin \frac{\alpha}{2}) \mathbf{n}^\top)^\top$
  • Quaternionen-Multiplikation anwenden:
    $\tilde{\mathbf{p}}_q = \mathbf{q}\, \mathbf{p}_q \,\mathbf{q}^{-1} = \mathbf{q}\, (0, x, y, z)^\top \,\mathbf{q}^{-1} $
  • Das resultierende Quaternion $\tilde{\mathbf{p}}_q$ wieder als kartesischen Punkt $\tilde{\mathbf{p}}$ schreiben, indem die letzten drei Komponenten extrahiert werden.

• Gegeben: Zwei Rotationsmatrizen, $\mathtt{R}_{0}$ zum Zeitpunkt $t=0$ und $\mathtt{R}_{1}$ zum Zeitpunkt $t=1$
• Kann eine zeitliche lineare Interpolation der Rotation folgendermaßen erreichen werden?
  $\mathtt{R}(t) = (1-t) \, \mathtt{R}_0 + t \, \mathtt{R}_1$ mit $t \in [0, 1]$

• Nein!
• Stattdessen lineare Interpolation des Rotationswinkels
  $\alpha(t) = (1-t)\, \alpha_0 + t\, \alpha_1$
  und anschließend $\alpha(t)$ mit Quaternionen (oder Eulerwinkeln) verwenden

• Quelltext mit GLUT: RotationInterpolation.cpp
• Quelltext mit Qt: RotationInterpolation.cpp
• Quelltext mit Java: RotationInterpolation.java

Anregungen oder Verbesserungsvorschläge können auch gerne per E-mail an mich gesendet werden: Kontakt

Weitere Vorlesungsfolien

Folien auf Englisch (Slides in English)