Perspektivische Projektion

Einleitung

• Projektion = Abbildung von 3D-Objekten in 2D-Bildebene

• Klassifikation von Kameramodellen

  • perspektivische Projektion

    • weiter entfernte Objekte erscheinen kleiner

    

  • Parallelprojektion

    

Lochkamera

• einfachstes Modell der perspektivischen Abbildung

• ähnlich menschlichem Auge

• 

• Schärfentiefe nimmt bei größerer Öffnung ab

• Computergrafik verwendet idealisiertes Lochkameramodell mit unendlich kleinem Loch

  • Tiefenunschärfe kann nicht direkt simuliert werden

  • imaginäre BIldebene liegt vor Projektionszentrum

    

mathematische Grundlagen

• $\begin{array}{c}\tilde{P}=\left(\begin{array}{c}f\frac{p_x}{p_z}\\ f\frac{p_y}{p_z}\\ f\end{array}\right)\end{array}$$\tilde P = \begin{pmatrix}f {p_x \over p_z} \\ f {p_y\over p_z }\\ f\end{pmatrix}$ (abgeleitet vom Strahlensatz: Steigungsverhältnis bleibt gleich)

• $\begin{array}{c}\tilde{P}=\left(\begin{array}{c}f\frac{p_x}{p_z}\\ f\frac{p_y}{p_z}\\ f\end{array}\right)\in \mathbb{R}³\to \underset{―}{\tilde{P}}=\left(\begin{array}{c}f{p}_x\\ f{p}_y\\ f{p}_z\\ p_z\end{array}\right)\in {\mathbb{H}}^3\end{array}$$\tilde P = \begin{pmatrix}f {p_x \over p_z} \\ f {p_y\over p_z }\\ f\end{pmatrix} \in \R³ \rightarrow \underline {\tilde P} = \begin{pmatrix}f p_x \\ f p_y\\ f p_z \\ p_z\end{pmatrix} \in \H^3$

• Abbildungsmatrix: $\begin{array}{c}\underset{―}{\tilde{P}}=\left(\begin{array}{c}f{p}_x\\ f{p}_y\\ f{p}_z\\ p_z\end{array}\right)=\left[\begin{array}{cccc}f& 0& 0& 0\\ 0& f& 0& 0\\ 0& 0& f& 0\\ 0& 0& 1& 0\end{array}\right]\ast \underset{―}{P}\end{array}$$\underline {\tilde P} = \begin{pmatrix}f p_x \\ f p_y\\ f p_z \\ p_z\end{pmatrix} = \begin{bmatrix}f & 0 & 0 & 0 \\ 0 & f & 0 & 0 \\ 0 & 0 & f & 0 \\ 0 & 0 & 1 & 0\end{bmatrix} * \underline P$

  • bei OpenGL zeigt die Kamera in negative z-Richtung, daher:

    $\begin{array}{c}\underset{―}{\tilde{P}}=\left(\begin{array}{c}f{p}_x\\ f{p}_y\\ f{p}_z\\ -p_z\end{array}\right)=\left[\begin{array}{cccc}f& 0& 0& 0\\ 0& f& 0& 0\\ 0& 0& f& 0\\ 0& 0& -1& 0\end{array}\right]\ast \underset{―}{P}\end{array}$$\underline {\tilde P} = \begin{pmatrix}f p_x \\ f p_y\\ f p_z \\ -p_z\end{pmatrix} = \begin{bmatrix}f & 0 & 0 & 0 \\ 0 & f & 0 & 0 \\ 0 & 0 & f & 0 \\ 0 & 0 & -1 & 0\end{bmatrix} * \underline P$

perspektivische Projektion in OpenGL

• Nearplane und Farplane verlaufen parallel zur Bildebene und begrenzen darzustellenden Bereich in z-Koordinate

  

  • wichtig, da unendlicher Bereich nicht mit endlicher Präzision darstellbar wäre
  • Bereich zwischen Near- und Farplane wird auf $[-1,1]$$[-1,1]$ normiert

• Für darzustellenden Bereich ist vor allem der Öffnungswinkel $\mathrm{\Theta }$$\Theta$ relevant, aus dem sich das Verhältnis von Bildgröße und Brennweite ergibt

  

  $f=cotan(0.5\ast \theta )$$f = cotan (0.5 * \theta)$

  • Größe der Bildebene wird in OpenGL so gewählt, dass x- und y-Koordinaten im Bereich $[-1,1]$$[-1, 1]$ liegen.

• Für Projektion von Kamerakoordinatensystem in Bildebene ist GL_PROJECTION-Matrix verantwortlich

  • Aktivierung durch glMatrixMode(GL_PROJECTION);

  • Erzeugen von Projektionsmatrix durch gluPerspective(fovy, aspect, near, far);

    

• Beispiel: Dolly Zoom / Vertigo Effekt

  Translation der Kamera in z-Richtung und Ausgleich durch Veränderung der Brennweite

  • Durch z.B. gleichzeitiges Herauszoomen und auf "Primärobjekt" zugehen, bleibt dieses gleich groß, Perspektive und Umgebung ändern sich aber.

  

Transformation der Kamera

• $\underset{―}{\tilde{P}}=A\ast T_{cam}^{-1}\ast T_{obj}\ast \underset{―}{P}$$\underline {\tilde P} = A * T_{cam}^{-1} * T_{obj} * \underline P$

  1. Punkt wird vom lokalen ins Weltkoordinatensystem transformiert: $T_{obj}$$T_{obj}$
  2. Weltkoordinatensystem wird ins Kamerakoordinatensystem transformiert: $T_{cam}^{-1}$$T_{cam}^{-1}$
  3. Kamerakoordinatensystem wird in die Bildebene transformiert: $A$$A$

• Transformationsmatrizen ergeben sich durch Basisvektoren (Linearkombination)

• In OpenGL werden alle Transformationen zu GL_MODELVIEW-Matrix zusammengefasst, außer Projektionsmatrix $A$$A$

  Damit beschreibt GL_MODELVIEW die Transformation aus lokalem Koordinatensystem in Kamerakoordinatensystem.

• Die GL_PROJECTION-Matrix $A$$A$ beschreibt die Abbildung vom Kamerakoordinatensystem in die Bildebene.

• Definition in OpenGL durch gluLookAt(eyex, eyey, eyez, refx, refy, refz, upx, upy, upz);

  

Einordnung in die fixed function pipeline

• Die beiden oberen Schritte sind Teil der Per-Vertex Operations und werden später durch Shader ersetzt.

Clipping

• in OpenGL-Pipeline vor perspektivischer Division,

  daher Prüfungsbereich $[-p_w;p_w]$$[-p_w; p_w]$ statt $[-1;1]$$[-1;1]$, da $-p_w<p_x<p_w\to -1<\frac{p_x}{p_w}<1$$-p_w < p_x < p_w \rightarrow -1 < {p_x \over p_w} < 1$

  • $p_y$$p_y$, $p_z$$p_z$ analog

• Die Division für geclippte Koordinaten wird damit eingespart.

Perspektivische Division

• überführt homogene Koordinaten ins kartesische Koordinatensystem durch Division durch letzt Koordinate
• hinterher sind alle Koordinaten im Bereich $[-1,1]$$[-1,1]$

Viewport Transformation

• Koordinaten aus Bereich $[-1;1]$$[-1;1]$ werden auf Bildschirmkoordinaten skaliert.

  

• Befehl: glViewport(int ix, int iy, int width, int height)

  • z.B. glViewport(0, 0, 1920, 1080) für FHD

Fluchtpunkte

• In perspektivischer Ansicht werden parallele Linien im 3D-Raum in der 2D-Projektion nicht zwingend parallel dargestellt.

• Schnittpunkte in 2D werden als Fluchtpunkte bezeichnet

• Entsprechend der Anzahl an Fluchtpunkten werden Projektionen als 1-, 2- oder 3-Punktperspektive bezeichnet.

  

Z-Buffer

• OpenGL-Implementierung für Tiefentests

  • Aktivierung durch glEnable(GL_DEPTH_TEST)

• Wenn inaktiv: Primitive werden in der Reihenfolge ihres Pipelinedurchlaufs gezeichnet und verdecken somit ggf. vorher gezeichnete.

• Wenn aktiv: Primitive, die näher an der Kamera liegen verdecken weiter entfernte.

• nach perspektivischer Division (Normalized device coordinates) haben weiter entfernte Punkte größere z-Koordinaten

• Depth-Buffer hält analog zum Framebuffers (Farbinformationen) die Tiefeninformationen pro Pixel

  

• wird mit z-Wert der Far-Ebene initialisiert:

  glClear(GL_DEPTH_BUFFER_BIT)

• Tiefenwert wird pixelweise vom Rasterisierer aus transformierten Vertex-Daten interpoliert

• Pixel (in Frame- und Depth-Buffer) werden in OpenGL-Pipeline während der Per-Fragment Operations geschrieben.

• Wenn Tiefenwert für Pixel kleiner ist, werden der bestehende und der entsprechende Farbwert überschrieben, ansonsten bleiben die bestehenden unverändert.

Z-Fighting

• Depth-Buffer hat nur gewisse Genauigkeit (16, 24, 32 Bit), auf dessen entsprechenden Intervall der Bereich der Normalized device coordinates abgebildet wird. Es muss somit gerundet werden.
• Genauigkeit nimmt bei weiter entfernten Objekten ab.
• Kommt es bei nah beieinander liegenden entfernten Koordinaten durch die Ungenauigkeit dazu, dass mal das eine, mal das andere dargestellt wird, bezeichnet man dies als Z-Fighting.
• Dieses Risiko wird durch möglichst geringen Bereich zwischen Near- und Farplane reduziert.