Kapitel 9 & 10
This commit is contained in:
parent
41ef7a9dc4
commit
07d9f7da2b
@ -509,7 +509,7 @@
|
||||
\item Bessere Verhältnisse der Grauabstufung ergeben sich für flache Winkel, wenn statt des "ordered grid" ein "rotated grid" für das Supersampling verwendet wird.
|
||||
\item Rotated grids sind dafür bei anderen Winkeln etwas schlechter als das ordered grid. Dies wird aber kaum wahrgenommen, da dort die Treppen der digitalen Geraden kürzer sind.
|
||||
\item Gute Grauabstufung bei sehr flachen Kanten zur Zeilen- oder Spaltenrichtung.
|
||||
\item Optimaler Winkel liegt bei ca. 20°-30° (z.B.$arctan(0.5) \approx 26,6°$).
|
||||
\item Optimaler Winkel liegt bei ca. 20°-30° (z.B.$arctan(0.5) \approx 26,6^{\circ}$).
|
||||
\item Sehr dünne Linien bleiben auch bei Bewegung zusammenhängend/sichtbar (Vermeidung von "Line Popping")
|
||||
\end{itemize}
|
||||
\paragraph{Supersampling + Multisampling}
|
||||
@ -863,7 +863,7 @@
|
||||
|
||||
\paragraph{Raumwinkel}
|
||||
Der Steradiant ist eine Maßeinheit für den Raumwinkel, der von der Mitte M einer Kugel mit Radius r aus gesehen eine Fläche von $r^2$ auf der Kugeloberfläche einnimmt. $\Omega=\frac{Flaeche}{Radius^2}=\frac{A}{r^2}sr$
|
||||
Eine komplette Kugeloberfläche $A_k$ beträgt allg. $A_k = 4\pi r^2$, entspricht also einem Raumwinkel $\Omega$ von $\frac{A_k}{r^2}= 4\pi r\approx 12,5sr$. Ein Steradiant =1sr entspricht einem Öffnungswinkel $\alpha$ von ca. 65,54°
|
||||
Eine komplette Kugeloberfläche $A_k$ beträgt allg. $A_k = 4\pi r^2$, entspricht also einem Raumwinkel $\Omega$ von $\frac{A_k}{r^2}= 4\pi r\approx 12,5sr$. Ein Steradiant =1sr entspricht einem Öffnungswinkel $\alpha$ von ca. $65,54^{\circ}$
|
||||
|
||||
\paragraph{Strahlstärke}
|
||||
\begin{itemize}
|
||||
@ -875,7 +875,7 @@
|
||||
\end{itemize}
|
||||
|
||||
Beispiel: Berechnen Sie die Strahlstärke einer Lampe mit einem Öffnungswinkel von 180° und einer Strahlungsleistung von 20W.
|
||||
$$\alpha=180°\rightarrow A=2\pi r^2; \phi =20W; \Omega=\frac{A}{r^2}=2\pi ; I_e=\frac{\phi_e}{\Omega}=\frac{20}{2\pi}\approx 3,2 \frac{W}{sr}$$
|
||||
$$\alpha=180^{\circ}\rightarrow A=2\pi r^2; \phi =20W; \Omega=\frac{A}{r^2}=2\pi ; I_e=\frac{\phi_e}{\Omega}=\frac{20}{2\pi}\approx 3,2 \frac{W}{sr}$$
|
||||
|
||||
\paragraph{Räumliche Ausbreitung}
|
||||
Energieübertragung zwischen zwei Flächen:
|
||||
@ -971,7 +971,7 @@
|
||||
$$\frac{A_r}{A'_r}=\frac{1}{\cos(\phi)} \rightarrow L=\frac{I_{out}}{\cos(\phi)}=I_{refl}$$
|
||||
Ein Betrachter mit flachem Blickwinkel sieht Licht aus größerer Fläche $A_r$ durch Kombination dieser Effekte, kürzt sich der Einfluss des Betrachterwinkels $\cos(\phi)$ weg und es bleibt nur der Einfluss des Lichteinfallswinkels übrig: Strahldichte des reflektierten Lichtes: $L=I_{in}*k_d(\lambda)*\cos(\phi)$
|
||||
|
||||
\paragraph{Spekuläre Reflexion
|
||||
\paragraph{Spekuläre Reflexion}
|
||||
Spekuläre (gestreut spiegelnde) Reflexion:
|
||||
\begin{itemize}
|
||||
\item Speckles (Fleckchen), bzw. (Micro-) Facetten sind einzeln jeweils "ideal"
|
||||
@ -1020,19 +1020,19 @@
|
||||
\item in der Computergrafik wird meist eine vereinfachte Variante gewählt um Rechenzeit zu sparen
|
||||
\item erstmals 1965 definiert (Fred Nicodemus): $f_r(\omega_i, \omega_r)=\frac{dL_r(\omega_r)}{dE_i(\omega_i)}=\frac{dL_r(\omega_r)}{L_i(\omega_i)\cos(\theta_i)d\omega_i}$
|
||||
\item Eine BRDF beschreibt wie eine gegebene Oberfläche Licht reflektiert.
|
||||
\item Das Verhältnis von reflektierter Strahldichte (radiance) $L_r$ in eine Richtung $\vec{ω}_r$ zur einfallenden Bestrahlungsstärke (irradiance) $E_i$ aus einer Richtung $\vec{ω}_i$ wird "bidirectional reflectance distribution function"(BRDF) genannt.
|
||||
\item Das Verhältnis von reflektierter Strahldichte (radiance) $L_r$ in eine Richtung $\vec{\omega}_r$ zur einfallenden Bestrahlungsstärke (irradiance) $E_i$ aus einer Richtung $\vec{\omega}_i$ wird "bidirectional reflectance distribution function"(BRDF) genannt.
|
||||
\item $p(\lambda)=\frac{L_r}{E_i}=[\frac{1}{sr}]$
|
||||
\item Die BRDF (für jeden Punkt x) ist eine 5-dimensionale skalare Funktion: $p(\lambda, \phi_e, \theta_e, \phi_i, \theta_i)$
|
||||
\item Keine Energie-Einheiten, nur Verhältniszahl!
|
||||
\item Kann durch Messung für verschiedene Materialien bestimmt werden (Messkamera/Normbeleuchtung)
|
||||
\item Eigenschaften der BRDF:
|
||||
\item Reziprozität: $ρ(\lambda)$ ändert sich nicht, wenn Einfalls- und Ausfallsrichtung vertauscht werden (wichtig für Ray-Tracing).
|
||||
\item $ρ(\lambda)$ kann anisotrop sein, d.h. der Anteil des reflektierten Lichtes ändert sich, wenn bei gleicher Einfalls- undAusfallsrichtung die Fläche um die Normale gedreht wird (Textilien, gebürstete Metalle, Metalleffektlacke)
|
||||
\item Reziprozität: $\rho(\lambda)$ ändert sich nicht, wenn Einfalls- und Ausfallsrichtung vertauscht werden (wichtig für Ray-Tracing).
|
||||
\item $\rho(\lambda)$ kann anisotrop sein, d.h. der Anteil des reflektierten Lichtes ändert sich, wenn bei gleicher Einfalls- undAusfallsrichtung die Fläche um die Normale gedreht wird (Textilien, gebürstete Metalle, Metalleffektlacke)
|
||||
\item Superposition gilt, d.h. mehrere Quellen überlagern sich linear.
|
||||
\end{itemize}
|
||||
|
||||
Es ist in der Computergrafik üblich, die bidirektionale Reflektivität als Gemisch von ambienten, diffusen und spekularen Komponenten $ρ_d, ρ_s$ aufzufassen und
|
||||
einen ambienten Anteil $ρ_a$ zu addieren. Für eine Menge Q von Lichtquellen berechnen wir damit die gesamte reflektierte Strahlstärke: $L_r=p_a*E_a+\sum_{1\leq j \leq Q} E_j * (k_d*p_d + k_s*p_s)$ mit $k_d+k_s=1$ und Q= Anzahl der Lichtquellen
|
||||
Es ist in der Computergrafik üblich, die bidirektionale Reflektivität als Gemisch von ambienten, diffusen und spekularen Komponenten $\rho_d, \rho_s$ aufzufassen und
|
||||
einen ambienten Anteil $\rho_a$ zu addieren. Für eine Menge Q von Lichtquellen berechnen wir damit die gesamte reflektierte Strahlstärke: $L_r=p_a*E_a+\sum_{1\leq j \leq Q} E_j * (k_d*p_d + k_s*p_s)$ mit $k_d+k_s=1$ und Q= Anzahl der Lichtquellen
|
||||
|
||||
\paragraph{Rendering-Equation}
|
||||
Für ambiente und gerichtete Lichtquellen aus der Hemisphäre ergibt sich eine spezielle Form der BRDF, die Render-Gleichung (Jim Kajiya 1986):
|
||||
@ -1277,7 +1277,7 @@
|
||||
\item Die 6 Teilpolygone können mittels Painter‘s Algorithmus korrekt sortiert und dargestellt werden
|
||||
\end{itemize}
|
||||
|
||||
Anwendungsbereiche des Painter ́s Algorithmus / Depth-Sort Algorithmus:
|
||||
Anwendungsbereiche des Painter's Algorithmus / Depth-Sort Algorithmus:
|
||||
\begin{itemize}
|
||||
\item Einfache Szenen, kleine Objekte, die sich in den z-Werten hinreichend unterscheiden.
|
||||
\item Dort, wo keine Hardware-Unterstützung für 3D-Rendering angeboten wird (begrenzter Speicher, keine Z-Buffer Unterstützung).
|
||||
@ -1551,7 +1551,7 @@
|
||||
$$F_{sr}=A_S \frac{\cos(\theta_s)*cos(\theta_r)}{\pi*r^2}*H_{sr}$$
|
||||
|
||||
Bei dicht benachbarten Flächen gelten die obigen, vereinfachenden Annahmen u.U. nicht mehr. Es müsste exakt gerechnet oder in diesen Bereichen feiner untergliedert werden.
|
||||
Wird statt $\beta8\lambdaβ$ vereinfachend ein konstanter Remissionsfaktor R (R diff im monochromatischen Fall oder $R_{diff R}, R_{diffG}, R_{diffB}$ für die drei typischen Farbkanäle) eingeführt, so ergibt sich zwischen der Strahldichte $L_r$ der bestrahlten Fläche und der Strahldichte $L_s$ der bestrahlenden Fläche der folgende Zusammenhang: $L_r=R_r*F_sr*L_s$
|
||||
Wird statt $\beta \lambda \beta$ vereinfachend ein konstanter Remissionsfaktor R (R diff im monochromatischen Fall oder $R_{diff R}, R_{diffG}, R_{diffB}$ für die drei typischen Farbkanäle) eingeführt, so ergibt sich zwischen der Strahldichte $L_r$ der bestrahlten Fläche und der Strahldichte $L_s$ der bestrahlenden Fläche der folgende Zusammenhang: $L_r=R_r*F_sr*L_s$
|
||||
|
||||
Jedes Patch wird nun als opaker Lambertscher (d.h. ideal diffuser) Emitter und Reflektor betrachtet (d.h. alle Lichtquellen werden genauso wie einfache remittierende Flächen behandelt, allerdings mit emittierendem Strahldichte-Term $L_{emr}$). $L_r=L_{emr}+R_r*\sum_S F_{sr}*L_s$
|
||||
|
||||
@ -1576,7 +1576,7 @@
|
||||
\item ein entsprechender Algorithmus, der die Patches einzeln behandelt, stammt von Cohen, Chen, Wallace und Greenberg
|
||||
\item akkumuliert mehr Energie in jedem Schritt, verletzt Gleichgewicht der Strahlung $\rightarrow$ Korrektur notwendig:
|
||||
$L_r^{k+1}=L_{emr} + R_r*\sum_s F_{sr}* L_s^k$
|
||||
\emd{itemize}
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\paragraph{Radiosity Eigenschaften}
|
||||
@ -1600,9 +1600,10 @@
|
||||
\item verschiedene Verfahren können kombiniert werden um die globale Beleuchtungsphänomene effizienter zu berechnen. - z. B. Radiosity + Ray Tracing: Indirekte diffuse Beleuchtung + Spiegelung und Schatten, etc.
|
||||
\end{itemize}
|
||||
|
||||
%\section{Texture Mapping
|
||||
%\subsection{ Bildbasiertes Rendering
|
||||
%\paragraph{Überblick
|
||||
\section{Texture Mapping}
|
||||
\subsection{ Bildbasiertes Rendering}
|
||||
\paragraph{Überblick}
|
||||
\begin{itemize}
|
||||
\item typische Anwendung: Applizieren von 2D-Rasterbildern auf 3D-Modellen
|
||||
\item Beispiele: Hausfassade, Holz-, Marmor-, Steintexturen, Tapeten, Stoffe etc.
|
||||
\item 3D-Objekte mit relativ einfachen Polygonen modelliert. - Details als Texturen, (d.h. als Raster-Bilder) - gelegentlich "Impostor" genannt.
|
||||
@ -1610,39 +1611,50 @@
|
||||
\item als Verallgemeinerung auch Image-based Rendering genannt
|
||||
\item Verwendung unterschiedlicher 3D-Transformationen und Beleuchtungsarten
|
||||
\item Spezielle Effekte! (Reflexionen, Schatten, ..)
|
||||
\end{itemize}
|
||||
|
||||
Erzeugung von Texturen:
|
||||
\begin{itemize}
|
||||
\item "reale" Texturen aus realen rasterisierten/digitalen Fotografien (aus Pixeln = "Picture-Elementen" werden Texel = "Texturelemente") vs.
|
||||
\item "berechnete" Texturen $\rightarrow$ synthetische Computergrafik-Bilder:
|
||||
\item vorberechnete reguläre Texturen (basieren auf Texeln) vs.
|
||||
\item nach Bedarf erzeugte statistische bzw. prozedurale Texturen (Absamplen von mathematischen Beschreibungen, ggf. beliebig genau)
|
||||
\end{itemize}
|
||||
|
||||
Anwendung von Texturen - Grundprinzipien:
|
||||
\begin{itemize}
|
||||
\item Transformation des Texturraums in den Bildraum der Darstellung: Verwendung unterschiedlicher geometrischer Transformationen (je nach Anwendungszweck)
|
||||
\item Resampling: transformiertes Texturraster wird aufs Bildraster "gerundet"
|
||||
\item Filtern: Verhindern/Abmildern von resampling-basierten Aliasing-Effekten
|
||||
\item Beleuchtung: RGB-Werte der Textur dienen als Materialattribute bei der Beleuchtungsrechnung
|
||||
\end{itemize}
|
||||
|
||||
Unterschiedliche Arten des Texturmappings (Transformationsfunktion):
|
||||
\begin{itemize}
|
||||
\item Parametrisches Mapping: Ein Rasterbild wird auf ein 3D-Polygon aufgebracht, indem man den Eckpunkten (x,y,z) des Polygons 2D-Texturkoordinaten (u,v) explizit zuordnet.
|
||||
\item affines Texturmapping: direkte affine Abbildung der Textur auf projizierte Polygone im Bildraum
|
||||
\item perspektivisches Texturmapping: Zwischenabbildung der Textur in den 3D-Objektraum und perspektivische Projektion in den Bildraum
|
||||
\item Projektives Texturmapping: Verwendung unterschiedlicher Projektionsarten (parallel, perspektivisch, eben, zylindrisch, sphärisch)
|
||||
\item Environment-Mapping: Spiegelung der Textur an der Oberfläche (bzw. Refraktion) mit entsprechender Verzerrung
|
||||
\item Transformation abhängig von Kameraposition!
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Affines Texturemapping
|
||||
\paragraph{Affines Texturemapping}
|
||||
Durch Zuordnung von 3 Punkten im Bildraster zu den entsprechenden 3 Punkten im Texturraster erhält man ein Gleichungssystem mit 6 Gleichungen und 6 Unbekannten $(a_u , b_u , c_u , a_v , b_v , c_v )$:
|
||||
\begin{itemize}
|
||||
\item $P_1: u_1=a_u*x_1+b_u*y_1+c_u; v_1=a_v*x_1+b_v*y_1+c_v$
|
||||
\item $P_2: u_2=a_u*x_2+b_u*y_2+c_u; v_2=a_v*x_2+b_v*y_2+c_v$
|
||||
\item $P_3: u_3=a_u*x_3+b_u*y_3+c_u; v_3=a_v*x_3+b_v*y_3+c_v$
|
||||
\end{itemize}
|
||||
|
||||
Für jedes Pixel(x,y) im Polygon: Resampling der Textur(u,v) bei der Rasterkonvertierung (Polygonfüllalgorithmus)
|
||||
|
||||
Für jedes Pixel(x,y) finde die Texturkoordinaten(u,v), d.h.:
|
||||
\begin{itemize}
|
||||
\item Rückwärtstransformation vom Ziel zum Original $\rightarrow$ keine Löcher im Bild!
|
||||
\item ABER: Texturkoordinaten können übersprungen oder wiederholt werden!
|
||||
\item Störsignale (Aliasing) $\rightarrow$ Filterung notwendig!
|
||||
\end{itemize}
|
||||
|
||||
Affines Mapping der Vertices x,y auf u,v $\rightarrow$ lineare Interpolation der u/v-Texturkoordinaten zwischen den Vertices für jedes Pixel (ähnlich wie RGB- bzw. Z-Werte im Polygonfüllalgorithmus, durch Ganzzahlarithmetik)
|
||||
|
||||
@ -1650,37 +1662,43 @@
|
||||
|
||||
Problem: Durch affine 2D-Abbildungen können nur Transformationen wie Rotation, Skalierung, Translation, Scherung in der Bild-Ebene abgebildet werden, aber keine Perspektive! $\rightarrow$ Abbildungsfehler zwischen den Eckpunkten! (kleine Dreiecke $\rightarrow$ kleiner Fehler!)
|
||||
|
||||
%\paragraph{Perspektivisches Texture-Mapping
|
||||
\paragraph{Perspektivisches Texture-Mapping}
|
||||
Beispiel: affine 3D-Abbildung der Textur per 4x4-Matrix auf 3D-Modell:
|
||||
Texturraum $\rightarrow$ Objektraum: Rotation, Translation, Skalierung (...) dann Objektraum $\rightarrow$ Bildraum: Projektion (selbe wie bei Geometrieprojektion)
|
||||
|
||||
%
|
||||
|
||||
entspricht affinem Textur-Mapping mit einem zusätzlichen Zwischenschritt, der Bestimmung der Objektraumkoordinaten:
|
||||
\begin{itemize}
|
||||
\item Matrix $M_{to}$: Koordinatentransformation vom Texturraum in den 3D- Objektraum (affine Abb.: 3D-Translation, -Rotation, -Skalierung)
|
||||
\item Matrix $M_{oi}$ : Koordinatentransformation vom Objektraum in den Bildraum (Kameratransformation, perspektivische Abbildung)
|
||||
\item Matrix $M_{ti}$: gesamte Koordinatentransformation vom Texturraum direkt in den Bildraum: $M_{ti} = M_{to}*M_{oi}$
|
||||
\item Matrix $M_{ti}^{-1}$: Inverse Koordinatentransformation vom Bildraum zurück in den Texturraum
|
||||
\end{itemize}
|
||||
|
||||
$\rightarrow$ 4x4-Matrix für homogene Koordinaten. Perspektivische Abbildung im Bildraum durch Division durch z, für jedes Pixel (wesentlich aufwendiger als lineare Interpolation)
|
||||
|
||||
Vergleich: Perspektivisches / Affines Texture Mapping:
|
||||
\begin{itemize}
|
||||
\item perspektivisches Textur-Mapping liefert auch bei perspektivischer Ansicht geometrisch korrekte Bilder
|
||||
\item etwas höherer Berechnungsaufwand pro Polygon, da für jedes Polygon zwei Transformationsmatrizen und eine inverse 4x4-Matrix bestimmt werden müssen
|
||||
\item wesentlich höherer Berechnungsaufwand pro Pixel: Matrixmultiplikation plus (floating-point) Division!
|
||||
\item bei affinem Textur-Mapping können hingegen einfach die Texturkoordinaten (u/v) zwischen den Polygonecken linear interpoliert werden:
|
||||
\item ähnlich wie bei anderen Attributen (z. B. x-Koordinate (s. Edge-Scan), r/g/b-Werte (s. Gouraud-Shading), Tiefenwerte (1/z) funktioniert dies inkrementell und mit Ganzzahlarithmetik (als Teil des Polygonfüllalgorithmus)
|
||||
\item je kleiner die Polygone im Bild, desto kleiner der Fehler beim affinen Texturemapping (Ansatz: feinere Unterteilung der Polygone in kleinere Dreiecke $\rightarrow$ dafür jedoch mehr Polygone!)
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Textur-Mapping mit Polygon-Schattierung
|
||||
\paragraph{Textur-Mapping mit Polygon-Schattierung}
|
||||
Eingliederung in die Render Pipeline
|
||||
\begin{itemize}
|
||||
\item Bestimmung der zum Polygon gehörenden sichtbaren Pixel im Bildraum (Polygonfüllalgorithmus)
|
||||
\item Ermittlung der zur jeder Pixelkoordinate gehörenden Texturkoordinate mit Hilfe der inversen Transformationsmatrix $M_{ti}^{-1}$
|
||||
\item Ermittlung der Farbe des zu setzenden Pixels aus dem Texturraster (und gegebenenfalls weitere Schattierung aus der Beleuchtungsrechnung)
|
||||
\item Beleuchtungsrechnung, z.B.: Multiplikation der Helligkeit einer beleuchteten diffusen weißen Oberfläche mit den r/g/b-Werten der Textur (Lambert Modell)
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%\paragraph{Weitere Texturarten
|
||||
\paragraph{Weitere Texturarten}
|
||||
\begin{itemize}
|
||||
\item Texturen mit Transparenz: RGBA-Wert zu jedem Pixel gespeichert, d.h. beim Rendern wird Alpha Blending mit der Hintergrundfarbe angewendet
|
||||
\item Video Texture: zeitlich veränderliche Textur, d.h. dynamische Veränderungen wie z.B. Feuer, Rauch (mit Alpha-Blending über Hintergrund / Billboard) oder Fernseher in der Wohnung mit Programm“ (ohne Alpha-Blending)
|
||||
\item Solid Textures:
|
||||
@ -1689,45 +1707,61 @@
|
||||
\item beim Rendern entweder auf Vertices angewendet und dann für Pixel linear interpoliert oder für jedes Pixel einzeln angewendet (Pixelshader)
|
||||
\item Anwendungsbsp.: Schnitt durch Material (z.B. Massivholz, Marmor) oder Volume Rendering (Überlagerung von Schichten) mit Alpha Blending, z.B. Computertomoraphie (CT-Daten)
|
||||
\item ggfs. auch Videotextur als Spezialfall einer Solid Texture: Zeit als 3. Dim.
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Projektives Textur-Mapping
|
||||
Berechnung der Texturkoordinaten aus der aktuellen Position der einzelnen Polygone (Analogie: Projektion eines Diapositivs auf ein räumliches Objekt)
|
||||
|
||||
Beispiel: Parallelprojektion mit fixer Position des Projektors zum Objekt
|
||||
\begin{itemize}
|
||||
\item 2D-Textur (Bsp. Gitter aus Millimeterskalen)
|
||||
\item Parallelprojektion der Textur auf einen Zylinder mit abgeschrägten Endflächen
|
||||
\item Projektion ist relativ zum Objekt definiert, d.h. die Textur bewegt sich mit dem Körper, sofern man diesen bewegt
|
||||
\item markierte Bereiche (1 bzw. 2) haben auf Zylinder stets identische Positionen
|
||||
\item keine explizite Zuordnung von uv-Koordinaten zu Polygoneckpunkten notwendig, weniger Modellieraufwand!
|
||||
\end{itemize}
|
||||
|
||||
Anwendungsbeispiele für projektives Textur-Mapping (Parallel- oder Zentralprojektion):
|
||||
\begin{itemize}
|
||||
\item Darstellung geometrischer Eigenschaften (geometrische Details, parallel, fixe Position des Projektors zum Objekt, senkrecht zur Fläche)
|
||||
\item einfache Darstellung von Parameterlinien (sofern die Textur senkrecht auf die Projektionsebene projiziert wird, parallel, fixiert bezgl. Objekt)
|
||||
\item Simulation eines Lichtkegels (Repräsentation der Leuchtdichteverteilung der Lichtquelle (Lichtfeld) als Rasterbild in einer Textur, zentral, fix in Weltkoordinaten)
|
||||
\end{itemize}
|
||||
|
||||
Zylindrisches Textur-Mapping:
|
||||
\begin{itemize}
|
||||
\item radiale Projektion der Textur-Koordinaten auf eine Zylinderoberfläche
|
||||
\item visueller Effekt für zylinderähnliche Objekte ähnlich zu parametrischem Textur-Mapping, z.B. Etikett auf Flasche, Dose, etc.
|
||||
\end{itemize}
|
||||
|
||||
Sphärisches Textur-Mapping:
|
||||
\begin{itemize}
|
||||
\item Zentralprojektion der Textur-Koordinaten auf eine Kugeloberfläche
|
||||
\item Vorteil des projektiven Texturmappings: Eine explizite Zuordnung der 3D-Punkte zu Texturkoordinaten mit stetiger Fortsetzung der Parametrisierung an den Polygongrenzen entfällt $\rightarrow$ weniger Modellieraufwand!
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Environment Mapping
|
||||
\paragraph{Environment Mapping}
|
||||
Spezialfall des projektiven Textur-Mapping:
|
||||
\begin{itemize}
|
||||
\item Simulation der Reflexion der Umgebung an einer reflektierenden Fläche
|
||||
\item Darstellung abhängig von der Position des Betrachters sowie von den Normalen der reflektierenden Fläche
|
||||
\item Textur entspricht der Lichtquelle für die Beleuchtung durch die Umgebung (Environment Map): Sphere Map bzw. Cube Map
|
||||
\end{itemize}
|
||||
|
||||
Mapping der Textur auf die spiegelnde Oberfläche:
|
||||
\begin{itemize}
|
||||
\item Aussenden eines Strahls vom Auge auf einen Punkt der spiegelnden Oberfläche
|
||||
\item Ermittlung der Reflexionsrichtung entsprechend dem Einfallswinkel des Strahl zur Flächennormale
|
||||
\item damit Bestimmung des zu reflektierenden Punktes in der Umgebung, d. h. des entsprechenden Textur-Pixels aus der Environment Map
|
||||
\end{itemize}
|
||||
|
||||
Grundannahme beim Environment Mapping:
|
||||
\begin{itemize}
|
||||
\item relativ große Entfernung der reflektierten Objekte von der spiegelnden Fläche
|
||||
\end{itemize}
|
||||
|
||||
Erzeugung einer Cube Map-Textur:
|
||||
\begin{itemize}
|
||||
\item Aufteilung der Environment Map in sechs Bereiche, die den sechs Flächen eines Würfels um die spiegelnde Fläche herum entsprechen
|
||||
\item Rendern der Umgebung sechs mal mit einem Kamera-Sichtfeld von jeweils 90 Grad aus dem Mittelpunkt des Würfels
|
||||
\item Alternativ: Digitale Aufnahme und Einpassen der sechs Flächen mittels Image Warping in die jeweiligen Zonen der Environment Map
|
||||
@ -1740,33 +1774,43 @@
|
||||
\item nur Einfachreflexion
|
||||
\item Cube Maps können dynamisch (durch Offline-Rendering in Texturbuffer) generiert werden. Dadurch auch bewegte gespiegelte Objekte in Echtzeit darstellbar
|
||||
\item Beachte: gespiegeltes Dreieck kann auf zwei oder mehrere Wände der Cube Map fallen. Dies kann durch mehrfaches Mapping und Clipping gelöst werden.
|
||||
\end{itemize}
|
||||
|
||||
Environment Mapping [Haeberli/Segal 1993] für Kugel und Torus:
|
||||
\begin{itemize}
|
||||
\item Unterschiedliche Ausrichtung der Objektoberfläche sorgt für korrekte Verzerrung der spiegelnden Objekte. Die Darstellung der spiegelnden Objekte (Geometrie und Material) steht beim Environment-Mapping im Vordergrund und nicht die korrekte geom. Darstellung gespiegelter Objekte!
|
||||
\item Alle Raumrichtungen werden auf der Kugeloberfläche abgebildet. Je nach Aufnahmegeometrie mehr oder weniger großer blinder Fleck“ hinter der Kugel.
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Erstellung einer Spherical-Environment-Map-Textur:
|
||||
\begin{itemize}
|
||||
\item spiegelnde Kugel in der Mitte einer Szene
|
||||
\item Fotografie der Kugel mit einer Kamera sehr großer (unendlicher) Brennweite aus großem (unendlichem) Abstand (parallele Projektionsstrahlen)
|
||||
\item Entstehung einer kreisförmigen Region in der Textur-Map mit den Tangenten jeweils an den Außenkanten
|
||||
\item Texturwerte außerhalb des Kreises werden nicht benötigt
|
||||
\item Wahl der Blickrichtung(-en) wichtig für spätere Anwendung!
|
||||
\end{itemize}
|
||||
|
||||
Anwendung einer Spherical Environment Map:
|
||||
\begin{itemize}
|
||||
\item Zur Bestimmung der Texturkoordinate eines dargestellten Punktes wird zuerst die Normale n an diesem Punkt bestimmt.
|
||||
\item Die Normale n wird auf die x/y- Ebene projiziert. Die Koordinaten des projizierten Normalenvektors entsprechen den Texturkoordinaten in der Sphere Map, welche die an dieser Stelle reflektierte Umgebung zeigt.
|
||||
\item Merke: Die Reflexion ist nicht von der Lage des reflektierenden Punktes abhängig (nur von der Normalenrichtung).
|
||||
\end{itemize}
|
||||
|
||||
Environment Map in latitude-/longitude-Koordinaten:
|
||||
\begin{itemize}
|
||||
\item Spiegelung wird aus Richtung des gespiegelten Strahls in Winkelkoordinaten (lat/long) berechnet
|
||||
\item entweder pro Pixel (Pixel-Shader) oder pro Vertex mit anschließender (linearer) Interpolation pro Pixel
|
||||
\item keine Berücksichtigung der Position des spiegelnden Objekts
|
||||
\item korrekt nur für unendlich entfernte gespiegelte Objekte $\rightarrow$ geeignet zur Spiegelung weit entfernter Objekte (Landschaften, große Räume auf relativ kleinen Objekten)
|
||||
\end{itemize}
|
||||
|
||||
|
||||
High-dynamic Range Imaging (HDRI) Env-Maps:
|
||||
\begin{itemize}
|
||||
\item enthalten "gesamte Dynamik" des Lichts (als Floating Point Farbwerte)
|
||||
\item Wesentlich realistischere Bilder!
|
||||
\item Tone Mapping: berechnete HDRI-Bilder werden anschließend auf die Dynamik des Monitors reduziert
|
||||
@ -1774,35 +1818,43 @@
|
||||
\item wie Spiegelung, jedoch Sekundärstrahl aus Sehstrahl über Brechungsindex und Oberflächennormale, statt gespiegelt
|
||||
\item Beispiel: Glas als Polygonflächen mit Rückseite + Normalen (2-fache Brechung!) + Spiegelung als Multi-Pass (Überlagerung zweier Effekte)
|
||||
\item kann im Zusammenhang mit Cube-Maps, Spherical oder Lat/Long Environment Maps angewendet werden
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%\subsection{ Mip-Mapping
|
||||
\subsection{ Mip-Mapping}
|
||||
Was? aus Originaltextur Bildung einer Menge jeweils kleinerer Texturen (halbe Kantenlänge)
|
||||
|
||||
Wozu? Vermeidung/Abmilderung von Aliasing-Effekten durch "Vorfilterung" und Anwendung der passend aufgelösten Textur(-en) (1 Pixel $\approx$ 1 Texel) per bilinearer Filterung oder trilinearer Filterung
|
||||
|
||||
%\paragraph{Sampling-Artefakte
|
||||
\paragraph{Sampling-Artefakte}
|
||||
Aliasing-Effekte durch Koordinatentransformation:
|
||||
\begin{itemize}
|
||||
\item Pixel der Textur und Pixel des dargestellten Bildes weisen (aufgrund der Bildtransformation) im Allgemeinen unterschiedliche Rastergrößen auf.
|
||||
\item simpler Ansatz: Berechnung der transformierten Texturkoordinaten als Floating-Point-Werte und Rundung auf ganze Zahlen
|
||||
\item bei inverser Transformation vom Zielbild zurück zur Textur dann keine Lücken im Bild, aber die Pixel der Textur können ausgelassen oder mehrfach verwendet werden (Bildpixel werden genau einmal angewendet)
|
||||
\item durch das Resampling der Textur auf das resultierende Bildraster entstehen oft Aliasing-Artefakte
|
||||
\end{itemize}
|
||||
|
||||
Zwei wesentlich unterschiedliche Situationen:
|
||||
\begin{itemize}
|
||||
\item Abbildung mehrerer Texturpixel auf ein Bildpixel (Unterabtastung) oder
|
||||
\item Abbildung eines Texturpixels auf mehrere Bildpixel ( Überabtastung)
|
||||
\item Filteroperationen zur Interpolation der Bildpixel-Färbung in jedem Fall notwendig, insbesondere bei der Unterabtastung wird ein vorheriges Tiefpassfiltern und Resampling notwendig!
|
||||
\item Ansonsten Verletzung des Abtasttheorems / Nyquistfrequenz!
|
||||
\end{itemize}
|
||||
|
||||
Beispiel perspektivische Verkürzung der Schachbretttextur:
|
||||
\begin{itemize}
|
||||
\item in Realität eigentlich starke Verkleinerung der Textur bei größerer Entfernung!
|
||||
\item $\rightarrow$ Moiré Muster - Originaltextur ist an diesen entfernten Stellen im Bild zur Laufzeit nicht mehr erkennbar (Unterabtastung, aus mehreren Texeln, welche "hinter einem Pixel liegen“, wird nur einer ausgwählt)
|
||||
\item Treppenstufen im Nahbereich resultieren aus Überabtastung (mehrere Pixel teilen selben Texel)
|
||||
\item Lösung: Textur muss vorher passend durch Tiefpassfilter in der Auflösung reduziert werden $\rightarrow$ Aufbau und Anwendung einer Mip-Map
|
||||
\item Ziel der Mip-Map: stets 1 Texel pro Pixel bereitstellen
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%\paragraph{Aufbau
|
||||
\paragraph{Aufbau}
|
||||
\begin{itemize}
|
||||
\item In 3D-Szenen können Körper mit der selben Textur vom Betrachter unterschiedlich weit weg sein. $\rightarrow$ im Bild oft Unterabtastung (Minification) oder Überabtastung (Magnification) und entsprechende Aliasing-Effekte durchs Resampling!
|
||||
\item Ansatz: Vorberechnung derselben Textur für verschiedene Entfernungen
|
||||
\item Stufe 1: volle Auflösung
|
||||
@ -1816,8 +1868,10 @@
|
||||
\item niedrige Auflösungsstufen werden durch Filterung aus den höheren berechnet:
|
||||
\item einfach: z.B. Mittelwert aus 4 Pixeln (Box-Filter) oder
|
||||
\item aufwendiger: z.B.: Gaußfilter (siehe Kap. Bildverarb.)
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Anwendung
|
||||
\paragraph{Anwendung}
|
||||
\begin{itemize}
|
||||
\item Beispiel: OpenGL-Filteroperationen im Bildraum (zur Laufzeit ausgeführt):
|
||||
\item GL\_NEAREST: Annahme des Wertes des nächstliegenden Textur-Pixels
|
||||
\item GL\_LINEAR: bilineare Interpolation: gewichteter linearer Durchschnitt aus einem 2x2-Feld der am nächsten liegenden Texturpixel
|
||||
@ -1826,74 +1880,96 @@
|
||||
\item Aus der Nähe betrachtet, wird das Texturraster auf dem Bildraster entsprechend skaliert (vergrößert).
|
||||
\item durch Runden der Texturkoordinaten (d.h. ohne Filterung)
|
||||
\item mit bilinearem Filter gewichtete Texturfarbwerte proportional zum Abstand vom gerundeten Koordinatenwert
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Zusammenfassung
|
||||
\paragraph{Zusammenfassung}
|
||||
Aufbau der Mip-Map (als Vorverarbeitungsschritt beim Rendering):
|
||||
\begin{itemize}
|
||||
\item Speicherung der Originaltextur
|
||||
\item rekursive Speicherung der geringer aufgelösten Texturen (je 1/2 Kantenlänge) bis hinunter zu einem einzelnen Pixel
|
||||
\end{itemize}
|
||||
|
||||
Vorteile:
|
||||
\begin{itemize}
|
||||
\item Filter-Operationen können bei Initialisierung der Textur vorausberechnet werden
|
||||
\item nur ein Drittel zusätzlicher Speicherplatzbedarf
|
||||
\end{itemize}
|
||||
|
||||
Darstellung mit Mip-Map Texturen (zur Laufzeit)
|
||||
\begin{itemize}
|
||||
\item Auswahl der passenden Auflösungsstufe k Skalierung berechnet aus der Entfernung zum Betrachter und der perspektivischen Verkürzung (siehe Kameratransf.): $d/z = (1/2)^k \rightarrow k = log_2(z)-log_2(d)$
|
||||
\item Transformation der Pixel zwischen den Textur-Eckkoordinaten der gewählten Auflösung auf das Polygon im Bildraum
|
||||
\item typ. Verwendung der linearen Filter zur Vermeidung von Aliasing-Effekten durch Trilineare Filterung: zusätzlich zu bilinearem Filteren in einer Mip-Map-Stufe wird linear gewichtet zwischen zwei Mip-Map-Stufen (auf-, bzw. abgerundete Werte von k) interpoliert: z. B. wenn $k = 2.3 \rightarrow 30\% Anteil_{k=3}$ und $70\% Anteil_{k=2}$
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%\paragraph{Anti-Aliasing
|
||||
\paragraph{Anti-Aliasing}
|
||||
Anti-Aliasing durch trilineare Filterung:
|
||||
\begin{itemize}
|
||||
\item Durch die perspektivische Verkürzung wird eine weiter hinten liegende Textur verkleinert und im Vordergrund vergrößert. Bei einer Skalierung kleiner als 1 überspringt die gerundete inverse Texturtransformation Pixel in der Textur (minification). Die im Bildraum gesampelten Texturpixel werden somit "willkürlich" ausgewählt. Dadurch können Treppenstufen und Moiré-Muster entstehen (Aliasing-Effekt: linkes Bild). Durch Mip-Mapping werden an diesen Stellen geringer aufgelöste (gefilterte) Texturen verwendet (Rechtes Bild: Mit Mip-Mapping und tri-linearer Filterung wird ein Anti- Aliasing-Effekt erreicht)
|
||||
\item Vergrößerte Darstellung: Trilinearen Filterung = lineare Filterung zwischen den zwei aufeinander-folgenden (am besten passenden) Mip-Map-Stufen + bilineare Filterung in jeder der beiden Stufen. $\rightarrow$ Kantenglättung, Tiefpassfilter (Mittelwert / hier Grauwerte)
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
%\paragraph{Rip-Maps
|
||||
\paragraph{Rip-Maps}
|
||||
Anisotrope Filterung:
|
||||
\begin{itemize}
|
||||
\item z.B. bei flacher Aufsicht ist die Verkleinerung in y-Richtung viel stärker als in x-Richtung!
|
||||
\item Ohne spezielle Maßnahmen für diesen Fall müsste jeweils die Mip-Map-Stufe mit der kleinsten Auflösung verwendet werden, sonst treten wieder Aliasing-Artefakte auf!
|
||||
\item $\rightarrow$ Dies führt zur unscharfen Texturabbildung.
|
||||
\item Abhilfe: Anisotrope Mip-Maps (= Rip-Maps, Rectangular Mip-Maps)
|
||||
\end{itemize}
|
||||
|
||||
Anisotropic Mip-Map (Rip-Map):
|
||||
\begin{itemize}
|
||||
\item Verschiedene Auflösungsstufen in x- und y-Richtung werden erzeugt, sodass für jede Situation die richtige Auflösung gefunden werden kann ohne beim Resampling das Abtast-theorem zu verletzen.
|
||||
\item Aber: Vierfacher Speicherbedarf gegenüber höchster Auflösung (statt 1,33 - s. MipMap)
|
||||
\item Aber: Vierfacher Speicherbedarf gegenüber höchster Auflösung
|
||||
\end{itemize}
|
||||
|
||||
|
||||
%\subsection{ Weitere Texturarten
|
||||
%\paragraph{Bump-Map
|
||||
\subsection{ Weitere Texturarten}
|
||||
\paragraph{Bump-Map}
|
||||
\begin{itemize}
|
||||
\item Reliefartige Texturen: Herkömmliche Texturen sehen aus der Distanz zwar akzeptabel aus, von Nahem betrachtet erscheinen sie flach.
|
||||
\item Grund: keine korrekte 3D-Beleuchtung, Abschattung, keine Verdeckung, etc.
|
||||
\item Idee: Verwendung zusätzlicher Texturen, welche Tiefeinformationen beinhalten
|
||||
|
||||
\end{itemize}
|
||||
\begin{itemize}
|
||||
\item Bump Map: Offset zur Polygonebene in Richtung der Normale als Grauwert“ der Textur kodiert
|
||||
\item Polygon: als Schnitt mit Normalenrichtung
|
||||
\item Anwendung des Offsets auf Polygonfläche (Drehung): Die Normale wird als Gradient der Bumpmap berechnet. Die Beleuchtung wird daraus wie bei der Normalmap pro Pixel berechnet.
|
||||
\item Ein Offset“ wird nicht berücksichtigt! $\rightarrow$ Als Konturen nicht erkennbar!
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
%\paragraph{Normal-Map
|
||||
\paragraph{Normal-Map}
|
||||
\begin{itemize}
|
||||
\item Normal-Map: Normalen Vektor x/y/z als RGB-Wert kodiert
|
||||
\item Polygon: als Schnitt mit Normalenrichtung
|
||||
\item Anwendung der Normal-Map auf Polygonfläche: Die Normale der N-Map modifiziert die Flächennormale (räumliche Drehung). Bei der Beleuchtungsberechnung wird für jedes Pixel die modifizierte Normale verwendet.
|
||||
\item Ein "Offset" wird nicht berücksichtigt! $\rightarrow$ Als Konturen nicht erkennbar!
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Parallax-Map
|
||||
\paragraph{Parallax-Map}
|
||||
\begin{itemize}
|
||||
\item Parallax Map Tomomichi Kaneko et al. 2001
|
||||
\item Ausgangsdaten: Bump Map
|
||||
\item Die u/v-Koordinaten der angezeigten Textur werden Entsprechend der Blickrichtung beim Look-up um $\delta u = h * \tan(\phi)$ verschoben. Die daraus resultierende Verzerrung verstärkt den 3D-Effekt, allerding ohne korrekte Berücksichtigung der Verdeckung
|
||||
\item Anwendung des Offsets auf Polygonfläche (Drehung): Anwendung der Bump Map des Offests auf Polygonfläche (räuml. Drehung der Modellkoord.) Die Normale wird als Gradient der Bumpmap berechnet. Die Beleuchtung wird daraus wie bei der Normalmap pro Pixel berechnet.
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Displacement-Map
|
||||
\paragraph{Displacement-Map}
|
||||
\begin{itemize}
|
||||
\item Ausgang: Wiederum Bump Map, jedoch Bestimmen des korrekten Schnitts eines Sehstrahls mit der Bump Map durch iterative Suche des Schnittpunktes
|
||||
\item Finde $u_0$ , sodass $u-u' = h(u') * \tan(\phi)$ mittels Bisektion entlang dem Sehstrahl
|
||||
\item Bei Mehrdeutigkeit: Finde $u_0$ am weitesten weg von $u$ $\rightarrow$ korrekte Verdeckung
|
||||
\item Silhouetten: Auch u/v-Koordinaten außerhalb der Polygongrenzen müssen berücksichtigt werden!
|
||||
\item aufwendige Shader Programme nötig
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Zusammenfassung
|
||||
\paragraph{Zusammenfassung}
|
||||
\begin{itemize}
|
||||
\item DECAL (Abziehbild) RGBA-Werte ohne Berücksichtigung der Beleuchtung (emmisiv, evtl. mit Alpha Wert (A) für transparente Anteile)
|
||||
\item DIFFUSE: RGB-Werte werden als diffuser Farbanteil mit Beleuchtung verrechnet
|
||||
\item Graustufen: Helligkeitsweit wird mit dem diffusen Materialfarben mutlipliziert.
|
||||
@ -1901,42 +1977,58 @@
|
||||
\item Normal Map: Normalisierte Normalenrichtung (als 2farbiges Rasterbild). Dient zur Modulierung der Flächennormalen und wird bei der Beleuchtung berücksichtigt. Farbwerte kommen aus der Materialkonstante des Polygons, oder aus der Diffuse Map (bzw. Specular Map). Ergibt aus der Ferne eine dreidimensionalen (reliefartige) Struktur.
|
||||
\item Bump Map: Statt der Normalen wird eine Erhöhung (in Richtung der Normalen) kodiert (grauwertiges Rasterbild). Die Normalenrichtung wird daraus als Gradient (Differenz zweier benachbarter Pixel) bei der Darstellung abgeleitet. Danach Beleuchtung wie Normal Map.
|
||||
\item Parallax Map: zusätzlich Pixelverschiebung als Funktion der Höhe und Kamerarichtung
|
||||
\end{itemize}
|
||||
|
||||
%\subsection{ Shadow Mapping
|
||||
1. Durchgang:
|
||||
\subsection{ Shadow Mapping}
|
||||
\begin{enumerate}
|
||||
\item Durchgang:
|
||||
\begin{itemize}
|
||||
\item Erzeugen der Shadow Map
|
||||
\item Darstellung (mit z-Werten) aus Sicht der Lichtquelle
|
||||
\item Kamera Koordinaten in der Lichtquelle zentriert (Matrix L)
|
||||
\item z-Puffer als Textur speichern
|
||||
2. Durchgang:
|
||||
\end{itemize}
|
||||
\item Durchgang:
|
||||
\begin{itemize}
|
||||
\item Kamera Ansicht: View Matrix: V (ebenfalls mit z-Puffer)
|
||||
\item $\rightarrow$ Um den Schatten zu erzeugen benötigen wir Shader mit Lookup in der Shadow Map-Textur:
|
||||
\item 4x4-Matrix: $M = V^{-1}*L$
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
|
||||
%
|
||||
|
||||
Shadow map look-up:
|
||||
\begin{itemize}
|
||||
\item Transformiere jedes Pixel aus dem Kameraraum in den Lichtraum
|
||||
\item $p'=L*V^{-1}*p$
|
||||
\item Vergleiche transformierte z-Werte $(p'_z)$ mit den z-Werten der Shadow Map $(z_s)$
|
||||
\item $(p'_z>z_s)$: im Schatten - keine Beleuchtung von der Lichtquelle
|
||||
\item sonst: Punkt ist von der Lichtquelle her sichtbar, wende Beleuchtung in der Schattierung des Pixels an
|
||||
\end{itemize}
|
||||
|
||||
%\paragraph{Probleme
|
||||
\paragraph{Probleme}
|
||||
Z-fighting beim Schattentest:
|
||||
\begin{itemize}
|
||||
\item Schattentest $(p_z' <= z_s )$ sollte für beleuchtete Pixel korrekt $(p'_z = z_s)$ ergeben.
|
||||
\item Aufgrund der Rechenungenauigkeit der Fließkomma-Arithmetik wird Gleichheit selten erreicht!
|
||||
\item Beleuchtete Polygone schatten sich teilweise selbst ab.
|
||||
\item Lösung: kleiner Offset im Schattentest: $IF (p'_z <= z_s + Offset...)$
|
||||
\item durch das Offset wird sichergestellt, dass keine falschen Schatten entstehen
|
||||
\end{itemize}
|
||||
|
||||
Uniform Shadow-Map
|
||||
\begin{itemize}
|
||||
\item Probleme: zu niedrige Auflösung der Shadow Map im Nahbereich, Großteil der Shadow Map ist irrelevant für Kameraansicht
|
||||
\end{itemize}
|
||||
|
||||
Perspektive Shadow-Map
|
||||
\begin{itemize}
|
||||
\item adaptive schiefsymtetrische Projektion; nicht uniforme perspektive Shadow Map
|
||||
\end{itemize}
|
||||
|
||||
%\subsection{ Zusammenfassung
|
||||
\subsection{ Zusammenfassung}
|
||||
\begin{itemize}
|
||||
\item Transformation des Texturraums in den Bildraum der Darstellung:
|
||||
\item Verwendung unterschiedlicher geometrische Transformationen (z. B affin, perspektivisch, Env. Maps, etc.)
|
||||
\item Anwendung immer als inverse Transformation!
|
||||
@ -1945,8 +2037,470 @@
|
||||
\item Lösung: Tiefpass-Filter vor der Transformation: Mipmapping, Anisotrope Filter.
|
||||
\item Beim Abtasten (Rekonstruktion):Trilineare Filterung in x, y, und k (Mip-Map-Stufe)
|
||||
\item Texturinhalt als Material, Beleuchtung, Geometrie interpretiert
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\section{Grafik Pipeline}
|
||||
\begin{itemize}
|
||||
\item algorithmisches Konzept, sowie Realisierung der Grafikkartenhardware ist vergleichbar mit Fließband
|
||||
\item spezialisierte Arbeitsstationen (Spezialprozessoren)
|
||||
\item jedes geometrische Objekt durchläuft Arbeitsstationen sequenziell
|
||||
\item Arbeitsschritte können dadurch gleichzeitig auf verschiedenen Daten ausgeführt werden
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Bestandteile}
|
||||
Programm API -> Treiber -> Vertex-Verarbeitung -> Primitivenbehandlung -> Rasterisierung \& Interpolation -> Fragment Verarbeitung -> Rasteroperation -> Bildspeicher
|
||||
|
||||
\subsection{Allgemeines}
|
||||
\begin{itemize}
|
||||
\item Anwendungsprogramm:
|
||||
\begin{itemize}
|
||||
\item läuft auf der CPU,
|
||||
\item definiert Daten und Befehlsabfolge,
|
||||
\item greift dazu über das Grafik-API (Application Programming Interface, z. B. OpenGL, Direct3D) auf die Grafikkarte zu
|
||||
\end{itemize}
|
||||
\item Treiber: übersetzt die Grafikbefehle des Programms in die Maschinensprache der speziellen Grafikhardware (Graphics Processing Unit / GPU, z.B. von nVidia, AMD oder Intel)
|
||||
\item Befehle und Daten werden über den Bus (z.B. PCI-Express) von der CPU auf die GPU übertragen
|
||||
\item OpenGL-Pipeline: Abarbeitung der Grafikbefehle auf der GPU
|
||||
\item Ausgabe des Bildspeichers auf dem Monitor
|
||||
\item Treiber schickt Daten/Befehle an die GPU (z. B. via PCIe -Bus)
|
||||
\item Funktionsausführung auf der GPU ist dann abhängig vom aktuellen Zustand (OpenGL State Machine bzw. den gewählten Shadern):z.B. vorher definierter Primitivtyp (hier GL Polygon), Transformation, Lichtquellen, Interpolationsart (z.B. Gouraud Shading vs. Flat Shading)
|
||||
\end{itemize}
|
||||
|
||||
Abarbeitungsreihenfolge auf der GPU:
|
||||
\begin{itemize}
|
||||
\item Empfangen der Vertices in einer geordneten Sequenz.
|
||||
\item Vertexverarbeitung via Vertex Shader. Jeder Input-Vertex im Datenstrom wird in einen Output-Vertex transformiert und beleuchtet.
|
||||
\item Primitive culling (Verwerfen wenn nicht sichtbar) und clipping (Abschneiden der Polygone am Rand)
|
||||
\item Rasterkonvertierung (Polygon Filling) und Interpolation der Attributwerte (x-Koordinate, 1/z, R, G, B, Texturkoordinaten u/v, ...)
|
||||
\item Die Daten jedes Fragmentes (Pixel/Subpixel) wird mit einem Fragment Shader verarbeitet. Zu jedem Fragment gehört eine Anzahl Attribute.
|
||||
\item Per-Sample Operationen: Blending (Alpha-Blending bei Transparenz), Tiefen- und Stencil- Operationen ...
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\subsection{Vertex-Verarbeitung}
|
||||
\begin{itemize}
|
||||
\item Transformationen: Modell-Transformation, Kamera-Transformation (Model View Matrix) → Matrixmultiplikationen → Skalarprodukt
|
||||
\item Beleuchtung (Lighting): Lichtquellen, diffuses \& spekuläres Material: (Gouraud Shading) Lambert, Phong-Modell → Skalarprodukt
|
||||
\item Skalarprodukte (Gleitkomma-Multiplikationen und Additionen) werden durch viele parallele Prozessoren auf der GPU effizient verarbeitet.
|
||||
\end{itemize}
|
||||
|
||||
%\subsection{Primitive & Primitivenbehandlung}
|
||||
%
|
||||
|
||||
\subsection{Rasterkonvertierung}
|
||||
\begin{itemize}
|
||||
\item Edge Tables bereits erzeugt (Polygonsetup in Primitivenbeh.)
|
||||
\item Rasterkonvertierung/Interpolation entspricht der Scan-Line-Konvertierung (s. Polygonfüllalgoritmus), generiert Pixel (Fragments)
|
||||
\item Interpolation der x-Werte der Kanten (siehe left edge scan /bzw. right edge scan)
|
||||
\item pro Scan Line: inkrementiere x-Wert (left edge, right edge) (OpenGL behandelt nur konvexe Polygone/Dreiecke – d. h. immer 2 Kanten pro Bildzeile!)
|
||||
\item lineare Interpolation weiterer Attribute:
|
||||
\begin{itemize}
|
||||
\item z (1/z)-Werte,
|
||||
\item RGB-Werte (Gouraud Shading),
|
||||
\item Texturkoordinaten u/v (affines Texturmapping),
|
||||
\item Normalen (Phong Shading)
|
||||
\end{itemize}
|
||||
\item sehr wenige Ganzzahloperationen pro Pixel/Bildzeile
|
||||
\item Ausnahmen: z. B. perspektivische Texture Maps (FP-Division!)
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\subsection{Fragment-Verarbeitung}
|
||||
Weiterverarbeitung auf Basis der interpolierten Attribute im Fragment Shader
|
||||
|
||||
Beispiel Phong-Shading: Berechnung des Phong-Beleuchtungsmodells auf Basis der vorher linear interpolierten Fragmentnormalen, -position und Materialdaten sowie der Daten der Lichtquellen und Kameraposition
|
||||
|
||||
\subsection{Rasteroperationen}
|
||||
\begin{itemize}
|
||||
\item Abschließende Auswahl/Zusammenfassung der berechneten Fragmentdaten (pro Pixel)
|
||||
\item Beispiel: nicht transparente Objekte, Übernahme der Farbwerte mit z-Position, welche am dichtesten an der Kamera ist (z-Buffer)
|
||||
\item Beispiel: transparente Objekte (z.B. Glashaus), lineares Blending zwischen schon existierenden Farbwerten und neuesten entsprechend der Transparenz
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Performance}
|
||||
Einfaches Modell zur Bestimmung der Rechenzeit T:
|
||||
$T = a * \text{Anzahl Vertices} + b * \text{Anzahl Bildpixel}$ (a = Aufwand pro Vertex, b = Aufwand pro Pixel)
|
||||
|
||||
\begin{itemize}
|
||||
\item Grafikkarten geben ihre Performance an in:
|
||||
\begin{itemize}
|
||||
\item Anzahl Polygone / Sekunde (Polygone mit kleiner Pixelanzahl)
|
||||
\item Anzahl verarbeitete Pixel / Sekunde
|
||||
\item z.B. ca. 100 Millionen Polygone/sec à 10 Pixel / Polygon (mit Texturen, tri-lineare Filterung, etc. mehrere Milliarden Pixel / s (Gouraud Shader) (Angaben: nVidia Geforce 6800 - Jahr 2005)
|
||||
\end{itemize}
|
||||
\item Problem der Grafik-Pipeline: Flaschenhals! - Langsamste Operation hält Pipeline auf (bestimmt Durchsatz) → Zwei extreme Situationen:
|
||||
\begin{itemize}
|
||||
\item Vertex-limited: viele Vertices, kleine Polygone (wenige Pixel), einfache lineare Interpolation der Vertex-Attribute pro Fragment (kleines b )
|
||||
\item Fill rate limited: anspruchsvolle Fragment-Shader (großes b), weniger dafür große Polygone (viele Pixel)
|
||||
\end{itemize}
|
||||
\item Außerdem: Grafikspeicher-Zugriffe sind teuer (Latenz und Bandbreite beachten!) z.B. Auslesen gerenderter Bilder aus dem Grafikspeicher
|
||||
\item Eine für die Grafikkarte angegebene Performance (z. B. 100 Mio Polygone/sec bei G-Force 6800) ist nur unter unrealistisch günstigen Bedingungen zu erreichen.
|
||||
\begin{itemize}
|
||||
\item d. h. z.B. nicht 100 Mio. unterschiedliche Polygone mit 1 fps (wegen Speicherbandbreite für Vertexzugriffe)
|
||||
\item auch nicht 10.000 Polygone mit 10.000 fps (da Framebuffer-Reset teuer)
|
||||
\item Herstellerangaben gelten nur unter optimalen Bedingungen (z. B. 10 Pixel / projiziertem Polygon)!
|
||||
\item realistisch (verschieden große Polygone) → ca. 1 Mio Polygone mit 10 fps (10 Mio Polygone/s) = 10\% der Peak Performance!
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
$$\text{Durchsatz (fps)} \approx \text{Konst.} / \text{Polygonanzahl}$$
|
||||
\begin{itemize}
|
||||
\item unter realitischem Durchsatz: Begrenzung durch Bildspeicher
|
||||
\item über realisitschem Durchsatz: Begrenzung durch Geometriespeicher
|
||||
\end{itemize}
|
||||
|
||||
%\subsection{Hardware-Architektur
|
||||
%
|
||||
|
||||
\section{Bildverarbeitung}
|
||||
\subsection{Operationen auf dem Bildraster}
|
||||
Problem der Vorwärtstransformation:
|
||||
\begin{itemize}
|
||||
\item Farbwerte sitzen im Zielbild an nicht ganzzahligen Koordinaten, das Ausgabegerät benötigt aber Farbwerte in einem Raster (ganzzahlige Koordinaten)
|
||||
\item durch Runden können Löcher im Bild entstehen, einige Pixel werden u. U. mehrfach belegt
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Problemdiskussion:
|
||||
\begin{itemize}
|
||||
\item 45° - Drehung eines 3x3 Pixel großen Quadrates $\rightarrow$ Den Koodinaten (-1,1) und (1,1) beinhalten 2 Pixel aus dem Original (0,2) ist kein Pixelzugeordnet!
|
||||
\item Runden: führt zu Ausfallartefakten, da bestimmte Zielbildpixel je nach Transformation nicht erreicht werden
|
||||
\item Betrachtung eines Bildes aus 2 Kamerapositionen (Stereo)
|
||||
\begin{itemize}
|
||||
\item Bild aus verschiedenen Kameraperspektiven betrachtet.
|
||||
\item Beide Kameras sind auf den gleichen Punkt FP gerichtet.
|
||||
\item Die unterschiedlichen Pixel des Quellbildes werden an unterschiedliche Positionen in den beiden Zielbildern (jeweils Kamerabild in Kamerakoordinatensystem) abgebildet (Vorwärtstransformation).
|
||||
\item Störstrukturen bei Skalierung auf jeweils beiden Bildern
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
Lösungs-Idee: Inverse Transformation
|
||||
\begin{itemize}
|
||||
\item inverse Transformation, d.h. indirekte Methode
|
||||
\item da jedes Pixel im Zielbild B an der Position (k, l) Ausgangspunkt der Rechnung ist, bleibt keines unbelegt
|
||||
\item keine Löcher mehr!
|
||||
\item Problem: Auch das Quellbild A ist nur an ganzzahligen Rasterpunkten i,j gegeben. Wie ermittelt man A(x,y) aus den Pixeln A(i,j) im Umfeld von x,y? Wie groß muss das Umfeld sein? → Resamplingproblem (Wiederabtastung)
|
||||
\end{itemize}
|
||||
|
||||
Lösungsansatz: Rückwärtstransformation der Pixelkoordinaten
|
||||
\begin{itemize}
|
||||
\item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild
|
||||
\item Es entstehen zwar keine Lücken im Zielbild, aber durch Rundung nichtganzzahliger Pixelkoordinaten auf den nächstenganzzahligen Wert können dennoch Aliasing-Artefakte entstehen: $B(k.l)=A(h^{-1}(k,l)$
|
||||
\begin{itemize}
|
||||
\item einzelne Pixel im Originalbild werden öfter gesampelt als andere
|
||||
\item einige Pixel im Originalbild werden ausgelassen!
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Rückwärtstransformation der Pixelkoordinaten mit Interpolation benachbarter Pixel:
|
||||
\begin{itemize}
|
||||
\item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild
|
||||
\item bei nicht ganzzahligen Pixelkoordinaten kann man zwischen den benachbarten Pixelwerten im Originalbild interpolieren (RGB-Werte) (Rekonstruktion eines genaueren Zwischenwertes / Antialiasing)
|
||||
\item dadurch werden die scharfen (aber ungenau positionierten Flächengrenzen) zwar unscharf. . .
|
||||
\item aber die wahrgenommenen Grenzen zwischen schwarzen und weißen Flächen können so zwischen den ganzzahligen Pixelwerten positioniert werden
|
||||
\item die empfundene Genauigkeit wird durch Antialiasing sogar erhöht!
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Rückwärtstransformation bei doppelter Auflösung des Zielbildes: Vergleich mit exakter Darstellung nur bei doppelter Auflösung möglich
|
||||
|
||||
Verkleinern eines Bildes durch Skalierung
|
||||
\begin{itemize}
|
||||
\item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild
|
||||
\begin{itemize}
|
||||
\item auch hier entstehen zwar keine Lücken im Zielbild beim Transformieren zusammenhängender Bilder
|
||||
\item aber beim Sampeln im Originalbild entstehen Aliasing-Artefakte:
|
||||
\item z.B. Auslassen jedes zweiten Pixels im Originalbild → Zielbild wird uniform weiß (oder schwarz)
|
||||
\end{itemize}
|
||||
\item exakte Lösung wäre nur bei doppelter Auflösung möglich
|
||||
\item jedoch Auflösung im Zielbild begrenzt, gute Näherung muss gefunden werden
|
||||
\item Näherung durch Sampeln und Interpolation mehrerer Nachbarpixel führt zu möglicher Lösung
|
||||
\end{itemize}
|
||||
|
||||
|
||||
Fazit:
|
||||
\begin{itemize}
|
||||
\item Vorwärtstransformation:
|
||||
\begin{itemize}
|
||||
\item gesuchte Farbwerte im Zielbild liegen nicht immer an ganzzahligen Koordinaten
|
||||
\item durch Rundung können Lücken im Zielbild entstehen
|
||||
\end{itemize}
|
||||
\item Rückwärtstransformation:
|
||||
\begin{itemize}
|
||||
\item es entstehen keine Lücken im Zielbild, dennoch können (Sampling) Artefakte (Aliasing) auftreten
|
||||
\item diese Artefakte können durch Interpolation mehrerer Pixel teilweise abmildert werden
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\subsection{Frequenzraum}
|
||||
Um das Thema Sampling und Rekonstruktion und Aliasing-Artefakte besser verstehen zu können und um eine möglichst optimale (und theoretisch begründbare) Lösung zu finden machen wir einen Ausflug in die Signaltheorie und digitale Filter.
|
||||
Zur Beschreibung der Filtereigenschaften wird der Frequenzraum des Bildes eingeführt.
|
||||
Def.: Frequenz ist die Wiederholrate eines periodischen Signals. Bei zeitabhängigen Signalen S(t) gibt die Frequenz an, wie oft sich das Signal pro Sekunde wiederholt: $f(Hertz)=\frac{1}{t}$
|
||||
|
||||
Ein Bild ist im zweidimensionalen Ortsraum definiert:
|
||||
\begin{itemize}
|
||||
\item Farb-/Helligkeitswert als Funktion des Ortes W(x,y)
|
||||
\item Bei ortsabhängigen Signalen (z.B. Bildmustern) ist mit Frequenz gemeint, nach welcher Distanz (in Pixeln gemessen) sich das Muster im Bild wiederholt.
|
||||
\item Die Umwandlung vom Ortsraum in den Frequenzraum (und umgekehrt) geschieht durch eine Fourier-Transformation.
|
||||
\begin{itemize}
|
||||
\item damit kann ein Bild im Frequenzraum f definiert werden
|
||||
\item $S(f)$ wird Spektrum genannt
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Beispiel: 2D-Spektrum eines Schachbrettmusters
|
||||
\begin{itemize}
|
||||
\item Kleinstes auf einem Pixelraster darstellbares Muster hat Durchmesser von 2 Pixel (d.h. 0,5 Wiederholungen pro Pixel)
|
||||
\item Höchste darstellbare Frequenz $f_x = f_y = 0,5 \text{Pixel}^{-1}$
|
||||
\item Diese Frequenz nennt man Nyquist-Frequenz!
|
||||
\end{itemize}
|
||||
|
||||
Bildraster als P-dimensionaler Vektorraum:
|
||||
\begin{itemize}
|
||||
\item Das diskrete Grauwertbild $F (i* \delta x, j * \delta y )$ habe M Spalten und N Zeilen
|
||||
\item $P = M * N$ (=Anzahl Bildpunkte) ist damit die Dimension des Primärdatenraumes des Bildes
|
||||
\item Wir stellen uns bewusst das Bild aus Punkten zusammengesetzt vor, d.h.
|
||||
\begin{itemize}
|
||||
\item wir können von $M * N$ Basisbildern der Dimension $M * N$ ausgehen, in denen jeweils nur ein Pixel den Wert 1 (weiß) besitzt (alle anderen Pixel Schwarz = 0)
|
||||
\item diese Basisbilder sind damit alle orthonormal → Wichtungsfaktoren durch inneres Produkt!
|
||||
\item sie ergeben in der grauwertgewichteten Summe das diskrete Bild F
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
Vektoroperationen im Bildraum: Mit der mathematischen Definition eines Rasterbildes als Vektor in einem hochdimensionalen Vektorraum, lassen sich viele Bildoperationen als Vektoroperatoren elegant darstellen
|
||||
\begin{itemize}
|
||||
\item z.B. Skalarprodukte zwischen zwei Bildern (Linearkombination lineare Unabhängigkeit)
|
||||
\item Basistransformation: Ganze Bilder (als Vektoren) dienen als Basis eines transformierten Bildraumes.
|
||||
\item Die neuen Basisvektoren müssen linear unanhängig sein und idealerweise orthonormal zueinander stehen.
|
||||
\item Eine Basistransformation entspricht einer "Drehung" des Vektorraumes um den Nullpunkt.
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Transformation}
|
||||
Jedes Pixel im gedrehten Raum entspricht einem Bild im Ursprungs-Raum.
|
||||
Jedes Bild ist eine Linearkombination der Basisvektoren, entspricht also einer gewichteten Addition von Bildern im Ursprungsraum.
|
||||
|
||||
%
|
||||
|
||||
4 neue Basisvektoren $B_i$ (2 x 2 Pixel), welche unterschiedliche Frequenzen darstellen
|
||||
|
||||
%
|
||||
%(Weiß=+1; Schwarz=-1; Grau=0)
|
||||
|
||||
Die 4 Basisvektoren stehen orthonormal zueinander. Test mittels paarweisen Skalar-produkten: $B_iB_k=\begin{cases}1 \text{ falls } i=k\\ 0 \text{ sonst }\end{cases}$.
|
||||
Jedes einzelne Pixel aber auch jedes Bild kann als Linearkombination aus 4 Basisvektoren $B_1$ bis $B_4$ konstruiert werden: $P=a*B_1+b*B_2+c*B_3+d*B_4$
|
||||
\begin{itemize}
|
||||
\item Gleichungssystem: 4 Gleichungen für die Koeffizienten a,b,c,d
|
||||
\item Berechnung der Frequenzanteile a bis d über Lösung des Gleichungssystems oder Projektion von P auf $B_1$ bis $B_4$ (mittels Skalarprodukt): $a=P*B_1$
|
||||
\end{itemize}
|
||||
%
|
||||
|
||||
Bsp: $a=P*B_1 = <-1, 1, -1, -1><\frac{1}{2}, \frac{1}{2}, \frac{1}{2}, \frac{1}{2}> = -1*\frac{1}{2}+1*\frac{1}{2}-1*\frac{1}{2}-1*\frac{1}{2} = -1$
|
||||
|
||||
|
||||
\paragraph{DCT - Discrete Cosinus Transformation}
|
||||
\begin{itemize}
|
||||
\item Spezielle Basistransformation: Cosinus Transformation
|
||||
\item Jedes Pixel im Cosinus Raum entspricht einem Bild mit Cosinus-Funktionen verschiedener Frequenzen oder Phasen (in x- oder y-Richtung)
|
||||
\begin{itemize}
|
||||
\item Links oben: Frequenz = Null (Durchschnittswert des Bildes)
|
||||
\item Rechts unten: Anteil der höchsten Frequenz
|
||||
\end{itemize}
|
||||
\item Der Cosinus Raum bildet ein Orthonormalsystem
|
||||
\item ein Pixelbild im Ursprungsraum lässt sich zusammensetzen als gewichtete Addition von Bildern mit unterschiedlichen Frequenzen → Spektralzerlegung
|
||||
\item Ähnlich funktioniert die Fouriertransformation (Sinus und Cosinustransformation)
|
||||
\end{itemize}
|
||||
|
||||
%
|
||||
|
||||
\paragraph{Fouriertransformation}
|
||||
\begin{itemize}
|
||||
\item Grundidee: jede beliebige periodische Funktion lässt sich darstellen als Summe von $\sin$ und $\cos$ Funktionen unterschiedlicher Frequenzen
|
||||
\item Transformation: verändert eine Funktion nicht, sondern stellt sie nur anders dar
|
||||
\item Transformation ist umkehrbar: somit existiert auch eine inverse Fourier-Transformation
|
||||
\item Hochpassfilter: ausblenden der tiefen Frequenzen im Frequenzraum
|
||||
%
|
||||
\item Tiefpassfilter: ausblenden der hohen Frequenzen im Frequenzraum
|
||||
%
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\paragraph{Signalrekonstruktion}
|
||||
\begin{itemize}
|
||||
\item die Abtastfrequenz viel höher als die Signalfrequenz im Original
|
||||
\item Konkret: Die Signalfrequenz liegt unter der halben Abtastfrequenz, der sogenannten Nyquistfrequenz
|
||||
\item Samplingtheorem von Nyquist:
|
||||
\begin{itemize}
|
||||
\item Signale unterhalb der Nyquistfrequenz der Samples können rekonstruiert werden
|
||||
\item andererseits: Signale oberhalb der Nyquistfrequenz können nicht rekonstruiert werden
|
||||
\item stattdessen entsteht ein völlig fremdes Signal, welches mit dem Original offensichtlich nichts mehr zu tun hat
|
||||
\item Aliasing-Effekt (entsteht z. B. auch bei digitalen Tonaufnahmen von hohen Frequenzen, wenn die Samplingrate für diese Frequenzen zu niedrig ist)
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Anitaliasing}
|
||||
\begin{itemize}
|
||||
\item Aliasing bei Bildern entsteht u.a. bei der Kameraaufnahme von diskreten, digitalen Bildern, wenn das Bild in Bezug auf das Abtastraster zu hohe Frequenzen enthält (Verletzung des Abtasttheorems).
|
||||
\item die höchste zulässige Frequenz wird als Nyquistfrequenz bezeichnet
|
||||
\begin{itemize}
|
||||
\item sie ist gleich der halben Abtastfrequenz:$K_{x,Nyqu}=\frac{1}{2*\delta x}, x = Pixelabstand$
|
||||
\item zum besseren Verständnis des Grundproblems noch mal drei Beispiele nebeneinander:
|
||||
%
|
||||
\item Nachträgliches Filtern kann das Aliasing nicht mehr beseitigen.
|
||||
\end{itemize}
|
||||
\item Rekonstruktion eines Signals mittels Interpolation durch Erzeugen weiterer Samples zwischen den gemessenen Samples mittels eines Interpolationsalgorithmus (Supersampling)
|
||||
\item z.B. durch polynomiale Interpolation (mehrere Nachbarsamples)
|
||||
\item Dennoch entsteht ein etwas gestörtes Signal (hier nicht harmonische Verzerrung / Modulation)
|
||||
\item → Aliasing-Effekt, allerdings in abgemildertem Umfang
|
||||
\end{itemize}
|
||||
|
||||
Bei der eingangs vorgeschlagenen Rückwärtstransformation (vom Zielbild zurück ins Originalbild) ist die Samplingrate durch das Zielbild bestimmt (d.h. ein Sample pro Pixel im Zielbild).
|
||||
Wir können damit das Aliasing Phänomen besser erklären: Bei der Verkleinerung um ein Faktor 2 ist die Samplingrate im Originalbild nur halb so groß wie die
|
||||
Nyquistfrequenz des Originalbildes! ($0,25 Pixel^{-1}$ statt $0,5 Pixel^{-1}$).
|
||||
Beim Sampeln mit zu niedriger Samplingrate (unterhalb der Nyquistfrequenz) kann das Originalbild nicht mehr rekonstruiert werden. Es entstehen Aliasingeffekte: Das Zielbild wird uniform weiß (oder schwarz, wenn Original um ein Pixel verschoben wird).
|
||||
Der Begriff der Nyquistfrequenz erklärt das bekannte Phänomen und verweist auf mögliche Lösungen.
|
||||
|
||||
Aliasing kann bei der Ausgabe von Graphiken oder Bildinhalten auf Ausgabegeräten entstehen, denn dieser Prozess ist in der Regel mit einer Rasterung (Rasterisation) verbunden.
|
||||
\begin{itemize}
|
||||
\item Dies betrifft die Computergraphik vielerorts und steht deshalb hier im Mittelpunkt!
|
||||
\item Aliasing entsteht in der Computergraphik insbesondere dann, wenn die Originale in viel höherer Auflösung vorliegen als das Raster des Ausgabegerätes (z.B. hochaufgelöste Bilder, feinste Texturen, aber auch beim Raytracing kleinster Objekte (Strahlverfolgung = Sampling), etc.)
|
||||
\item Aliasing kann auch bei digitalen Fotografien von kleinteiligen (analogen) Mustern entstehen.
|
||||
\item Da sich Aliasing-Artefakte nicht nachträglich beseitigen lassen, kann Anti-Aliasing nicht erst dann ansetzen, wenn das Bild bereits fertig gerendert ist.
|
||||
\item Beachte: Tiefpassfilterung muss deshalb immer vor dem Resampling angewendet werden.
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Anwendung Tiefpassfilter}
|
||||
Um Bild (durch **Koordinatentransformation**) korrekt rekonstruieren zu können, müssen wir zuerst im Originalbild die hohen Frequenzen, die oberhalb der Nyquistfrequenz des Zielbildes liegen, eliminieren.
|
||||
|
||||
Um Bild (durch **inverse Transformation**) korrekt rekonstruieren zu können müssen wir:
|
||||
\begin{itemize}
|
||||
\item Zuerst im Originalbild die hohen Frequenzen, die oberhalb der Samplingrate des Zielbildes transformiert in das Originalbild liegen, eliminieren.
|
||||
\item Danach Sampling des gefilterten Originalbildes durch inverse Transformation jedes Pixels im Zielbild
|
||||
\end{itemize}
|
||||
|
||||
→ Die höchsten Frequenzen des Originalbildes können aufgrund der zu geringen Auflösung im Zielbild ohnehin nicht dargestellt werden. Dieser Ansatz findet die beste Lösung unter den gegebenen Umständen.
|
||||
|
||||
Achtung! Reihenfolge ist wichtig: Wenn man zuerst sampelt und dann das Zielbild filtert, lässt sich u.U. die Originalinformation (wenn dort Frequenzen oberhalb der Nyquistfrequenz enthalten sind) nicht mehr rekonstruieren!
|
||||
|
||||
\subsection{Rekonstruktionsfilter}
|
||||
Die oben beschriebene Filterung im Frequenzraum erfordert eine Fouriertransformation des Bildes in den Frequenzraum. Nach Eliminierung der hohen Frequenzen ist die Rücktransformation erforderlich. Dies ist noch sehr aufwendig!
|
||||
|
||||
Das selbe Ergebnis können wir einfacher erreichen, indem wir die Filterfunktion vom Frequenzraum in den Ortsraum transformieren (durch eine inverse Fouriertransformation) und dann direkt im Ortsraum anwenden:
|
||||
\begin{itemize}
|
||||
\item Box-Filter = ideales Tiefpass-Filter in Frequenzraum; eliminiert alle Frequenzen oberhalb
|
||||
\item Boxfilter im FR = sinc-Funktion im Ortsraum (Fouriertransformierte der Rechtecksf.) $sinc(x)=\frac{sin(x)}{x}$
|
||||
\end{itemize}
|
||||
|
||||
Rekonstruktion von Zwischenpixelwerten durch Interpolation benachbarter Pixel:
|
||||
\begin{itemize}
|
||||
\item Inverse Transformation der Koordination vom Zielbild + Sampling im Originalbild
|
||||
\item Bei einer Vergrößerung findet hierbei eine Überabtastung statt (d. h. das Signal im Originalbild liegt unter der halben Nyquistfrequenz der Samplingrate des Zielbildes)
|
||||
\item Zur genauen Rekonstruktion von Zwischenwerten kann man interpolieren, d.h. ein gewichtetes Mittel zwischen Werten der benachbarten Pixel im Originalbild berechnen
|
||||
\item Dadurch werden die scharfen (aber ungenau positionierten Flächengrenzen) zwar unscharf... Aber die wahrgenommene Genauigkeit nimmt zu → Antialiasing
|
||||
\item Zur Gewichtung können ebenfalls Filterfunktionen im Ortsraum verwendet werden – Cut-off-Frequenz = Nyquistfrequenz im Originalbild (z. B. lineare Interpolation oder Nearest Neighbor, Sinc Funktion, etc.)
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Exakte Interpolation}
|
||||
Rekonstruktionsfilter (supersampling) per Sinc-Funktion (Exakte Interpolation):
|
||||
\begin{itemize}
|
||||
\item Inverse Transformation: $B(k, l) = A(h^{-1} \{k, l\}) = A(x, y )$
|
||||
\item Interpolationsansatz 1 für das Resampling:
|
||||
\begin{itemize}
|
||||
\item gewichtete Überlagerung der Abtastwerte aus der lokalen Umgebung des Quellbildes. Die Gewichte werden durch Interpolationsfunktionen festgelegt. Die Interpolations-funktionen bestimmen die Qualität des Zielbildes (Störungen, Artefakte).
|
||||
\item $A(x,y)=\sum_{i=-\infty}^{\infty}\sum_{j=-\infty}^{\infty}A(i,j) * f_{int}(x-i, y-j)$
|
||||
\item Filterkern $f_{int}$ ist zentriert um das Pixel $A(x, y)$
|
||||
\item Filter ist selbst auch als Rasterbild definiert
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
Anwendung der Filter auf Bildinformationen:
|
||||
$$G(x,y)=\sum_{m=-size}^{size} \sum_{n=-size}^{size} F(x+m, y+n) * H(m,n)$$
|
||||
mit Ausgabebild $G(x,y)$, Eingabebild $F(x+m,y+n)$ und Filterkern $H(m,n)$
|
||||
|
||||
Beispiel 3x3 Spalttiefpass (Boxfilter im Ortsraum):
|
||||
\begin{itemize}
|
||||
\item $m=(-1,1), n=(-1,1)$
|
||||
\item $H=\frac{1}{9} \begin{pmatrix} 1&1&1\\ 1&1&1 \\ 1&1&1 \end{pmatrix}$
|
||||
\item einfache Mittelwertbildung der Nachbarpixel → unscharfes Bild und hochfrequente Artefakte
|
||||
\item Faltungsoperatoren zur Tiefpassfilterung → Beispiel Rauschunterdrückung
|
||||
\end{itemize}
|
||||
|
||||
Beispiel Filterfern: 5x5 Binominalfilter
|
||||
|
||||
$H_{5x5} =\frac{1}{256} * \begin{pmatrix} 1\\4\\6\\4\\1 \end{pmatrix} \begin{pmatrix} 1&4&6&4&1 \end{pmatrix}=\frac{1}{256} \begin{pmatrix} 1&4&6&4&1\\ 4&16&24&16&4\\ 6&24&36&24&6\\ 4&16&24&16&4\\ 1&4&6&4&1 \end{pmatrix}$
|
||||
|
||||
Interpolatiponsansatz 1 / Methode 1: Exakte Interpolation
|
||||
\begin{itemize}
|
||||
\item Hinreichend bandbegrenzte Bilder lassen sich theoretisch exakt interpolieren: Multiplikation des Quellbild-spektrum mit Rechtecktiefpass im Frequenzbereich
|
||||
\item Im Ortsbereich führt das auf eine diskrete Faltung mit der sinc-Funktion.
|
||||
\item In der Theorie gibt es keinerlei Störungen / keine Artefakte.
|
||||
\item Praxisproblem: die sinc-Funktion ist unendlich ausgedehnt!
|
||||
\end{itemize}
|
||||
|
||||
Sinc-Filter: Das Sinc-Filter ist zwar theoretisch ideal (scharfe Grenze im Frequenzraum) doch gilt dies nur bei gleichmäßiger Abtastung über der Nyquist-Frequenz, was in der Computergrafik meist nicht realisierbar ist. Besonders bei Kanten führt der Sinc-Filter zu starken Ringing-Artefakten.
|
||||
Die Sinc-Funktion einen unendlichen Träger, sodass zur Berechnung des Farbwerts eines Pixels alle Abtastwerte des Bildes herangezogen werden müssen. Ein einfaches Abschneiden der Sinc-Funktion (Lanczos-Filter) führt zu schlechten Ergebnissen.
|
||||
|
||||
\begin{itemize}
|
||||
\item Box-Filter
|
||||
\begin{itemize}
|
||||
\item Alle Abtastwerte innerhalb eines um das Pixel gelegte Quadrat (meist mit der Kantenlänge von einem Pixelabstand) haben die gleiche Gewichtung: → Mittelwertbildung
|
||||
\item Das Box-Filter liefert im Allgemeinen schlechte Ergebnisse, da seine Fourier-Transformierte eine Sinc-Funktion ist, die den gewünschten Frequenzbereich nur schlecht isoliert
|
||||
\end{itemize}
|
||||
|
||||
\item Kegel-Filter
|
||||
\begin{itemize}
|
||||
\item Beim Kegel-Filter fällt die Gewichtung mit zunehmender Distanz zum Pixel linear ab.
|
||||
\item Es liefert etwas bessere Ergebnisse als das Box-Filter
|
||||
\item Artefakte sind noch vorhanden, aber deutlich abgeschwächt!
|
||||
\end{itemize}
|
||||
|
||||
\item Gauß-Filter
|
||||
\begin{itemize}
|
||||
\item Beim Gauß-Filter wird zur Rekonstruktion eine Gauß-Funktion verwendet. Die Fouriertransformierte einer Gauß-Funktion ist wieder eine Gauß-Funktion.
|
||||
\item Dieser Filter führt zu Unschärfe (höhere Frequenzen, auch unterhalb der Nyquistfrequenz werden zu stark abgeschwächt),
|
||||
\item dafür werden aber Aliasing-Effekte sehr gut unterdrückt
|
||||
\end{itemize}
|
||||
|
||||
\item Mitchell-Netravali-Filter
|
||||
\begin{itemize}
|
||||
\item sind stückweise kubische Filter mit vier Pixel breiten Trägern.
|
||||
\item Sie sind durch zwei freie Parameter änderbar und wurden speziell dafür entworfen, die aus Rekonstruktionsfiltern resultierenden Artefakte zu untersuchen.
|
||||
\item Bei geeigneter Parameterwahl liefern die Filter einen guten Kompromiss zwischen Unschärfe, Anisotropie und Ringing.
|
||||
\item Die Mitchell-Netravali-Filter werden auch als bikubische Filter bezeichnet, z. B. kubische B-Splines, o. Ä.
|
||||
\end{itemize}
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Nearest Neighbour}
|
||||
\begin{itemize}
|
||||
\item Einfache Übernahme des geometrisch nächsten Nachbarn aus dem Quellbild.
|
||||
\item Entspricht der Faltung mit einem Rechteck der Breite$\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer Sinc-Funktion im Frequenzbereich.
|
||||
\item Ergebnis: Massive Störungen (Artefakte) durch skalierte, z.T. phasengespiegelte Reste von periodifizierten Frequenzanteilen. Verunschärfungen halten sich in Grenzen, da die entsprechende sinc-Funktion bei der Nyquistfrequenz noch nicht wesentlich abgefallen ist. Die unsymmetrische Operation führt zu frequenzabhängigen, örtlichen Verschiebungen.
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Bilinearer Interpolation}
|
||||
\begin{itemize}
|
||||
\item Entspricht der Faltung mit einem Dreieck der Breite $2*\delta x$ im Ortsbereich, d.h. Multiplikation des periodifizierten Bildspektrums mit einer $sinc^2$-Funktion im Frequenzbereich.
|
||||
\item Reduziertes Aliasing / Artefakte durch schnelleren Abfall der $sinc^2$-Funktion gegenüber sinc, merkliche Verunschärfung durch stärkeren Abfall bei der Nyquistfrequenz. Außermittige Interpolation führt zu frequenzabhängigen örtlichen Verschiebungen (Achtung bei Messanwendungen).
|
||||
\end{itemize}
|
||||
|
||||
\paragraph{Weitere Filter}
|
||||
\begin{itemize}
|
||||
\item Filter zur Hoch- bzw. Bandpassfilterung:
|
||||
\item Anwendung: z.B. Kantenextraktion
|
||||
\item Sobelgradient: $H_{xS} =\begin{pmatrix} 1&0&-1\\ 2&0&-2\\ 1&0&-1\end{pmatrix}, H_{yS}=\begin{pmatrix} 1&2&1\\ 0&0&0\\ -1&-2&-1 \end{pmatrix}$
|
||||
\item Differenzbildung (Ableitung) → hohe Frequenzen werden verstärkt!
|
||||
\item im Gegensatz dazu sind Tiefpassfilter Integralfilter = gewichtete Summe der Nachbarpixel
|
||||
\end{itemize}
|
||||
|
||||
|
||||
\end{multicols}
|
||||
\end{document}
|
||||
Loading…
Reference in New Issue
Block a user