Übungen zu den Lehrveranstaltungen 710.003 Computergrafik 1 ...

Übungen zu den Lehrveranstaltungen
710.003 Computergrafik 1
710.005 Computer Vision 1
Institut für Maschinelles Sehen und Darstellen
Sommersemester 2011
Horst Bischof, Gerhard Reitmayr,
Andreas Wendel, Thomas Mauthner, Denis Kalkofen, Marc Streit, Alexander Lex
4. März 2011
1 Allgemeines
Dieses Dokument enthält die Aufgabenstellungen für die Einführungslehrveranstaltungen „Computergrafik
1“ und „Computer Vision 1“, die vom Institut für Maschinelles Sehen und Darstellen im Sommersemester
2011 angeboten werden. Die Aufgabenstellungen zu „Computergrafik 2“ und „Computer Vision 2“ folgen
in einem separaten Dokument. Bitte lesen Sie in Tabelle 1 nach, welche Aufgaben für die von Ihnen
besuchten Lehrveranstaltungen benötigt werden.
Lehrveranstaltung Übungsbeispiel(e)
710.003 Computergrafik 1 cg/task1a + cg/task1b
710.004 Computergrafik 2 cg/task2
710.005 Computer Vision 1 cv/task1a + cv/task1b
710.006 Computer Vision 2 cv/task2
Tabelle 1: Zuordnungen der Übungsbeispiele zu den Modulen
Diese Lehrveranstaltungen wurden mit dem Sommersemester 2007 neu eingeführt und ersetzen die entsprechenden
bis zum Sommersemester 2006 angebotenen Lehrveranstaltungen. Sollten in Ihrem Studienplan
also noch die alten Bezeichnungen aufgelistet sein, gelten die Äquivalenzen laut Tabelle 2.
alte Lehrveranstaltung
äquivalent zu
710.040 Bildanalyse und Computergrafik 710.003 + 710.005
710.060 Visuelle Informationssysteme 710.003 + 710.005
710.106 Computer Vision 710.005 + 710.006
710.107 Computer Grafik 710.003 + 710.004
710.552 Bildanalyse und Computergrafik für SEWM 710.006
710.662 Visuelle Informationssysteme für Telematiker 710.004
Tabelle 2: Äquivalenzen zwischen den bis 2006 angebotenen und den ab 2007 angebotenen Einführungslehrveranstaltungen
des ICG
1

Die Aufgaben bestehen jeweils aus mehreren Schritten, die zum Teil aufeinander aufbauen, jedoch unabhängig
voneinander beurteilt werden. Dadurch ist einerseits eine objektive Beurteilung sichergestellt
und andererseits gewährleistet, dass auch bei unvollständiger Lösung der Aufgaben Punkte erzielt werden
können. Als Ergänzung zur Aufgabenstellung werden im Sekretariat des ICG ab 07. März 2011 einzelne
Abschnitte der im Literaturverzeichnis erwähnten Bücher zur Kopie aufliegen (gegen Hinterlegung des
Studentenausweises). Wir empfehlen Ihnen, von diesem Angebot Gebrauch zu machen, da Sie in diesem
Dokument nur eine kurze Einführung zu den jeweiligen Übungsthemen finden.
Wir weisen ausdrücklich darauf hin, dass die Übungsaufgaben von jedem Teilnehmer eigenständig
gelöst werden müssen. Wenn Quellcode anderen Teilnehmern zugänglich gemacht wird (bewusst
oder durch Vernachlässigung eines gewissen Mindestmaßes an Datensicherheit), wird das betreffende
Beispiel bei allen Beteiligten mit 0 Punkten bewertet, unabhängig davon, wer den Code ursprünglich
erstellt hat. Ebenso ist es nicht zulässig, Code aus dem Internet, aus Büchern oder aus anderen
Quellen zu verwenden. Es erfolgt sowohl eine automatische als auch eine manuelle Überprüfung auf
Plagiate.
Da die abgegebenen Programme halbautomatisch getestet werden, muss die Übergabe der Parameter mit
Hilfe von entsprechenden Konfigurationsdateien genauso erfolgen wie bei den einzelnen Beispielen spezifiziert.
Insbesondere ist eine interaktive Eingabe von Parametern nicht zulässig. Sollte aufgrund von Änderungen
am Konfigurationssystem die Ausführung der abgegebenen Dateien mit den Testdaten fehlschlagen,
wird das Beispiel mit 0 Punkten bewertet. Die Konfigurationsdateien liegen im XML-Format vor, zu deren
Auswertung steht Ihnen die Klasse Config zur Verfügung. Die Verwendung der Klasse ist aus dem
Programmgerüst ersichtlich.
Jede Konfigurationsdatei enthält zumindest einen Testfall und dessen Konfiguration. Es ist auch möglich,
dass eine Konfigurationsdatei mehrere Testfälle enthält, um gemeinsame Parameter nicht mehrfach in verschiedenen
Dateien spezifizieren zu müssen. In manchen Konfigurationsdateien finden sich auch einstellbare
Parameter, die in Form eines select Feldes vorliegen. Diese sollen die Handhabung der Konfigurationsdateien
erleichtern und ein einfaches Umschalten der Modi gewährleisten.
Es steht Ihnen frei, z.B. zu Testzwecken eigene Erweiterungen zu implementieren. Stellen Sie jedoch sicher,
dass solche Erweiterungen in Ihrem abgegebenen Code deaktiviert sind, damit ein Vergleich der
abgegebenen Arbeiten mit unserer Referenzimplementierung möglich ist.
Die Programmgerüste, die zur Verfügung gestellt werden, sind unmittelbar aus unserer Referenzimplementierung
abgeleitet, indem nur jene Teile entfernt wurden, die dem Inhalt der Übung entsprechen. Die
Verwendung dieser Gerüste ist nicht zwingend, aber Sie ersparen sich sehr viel Arbeit, wenn Sie davon
Gebrauch machen.
2 Steganographie („CV/task1a“)
Der Begriff Steganographie steht für das Verbergen von digitalen Inhalten in Computerdateien. Audiound
Bilddaten enthalten meist einen hohen Rauschanteil, der durch gezielt platzierte Informationen ersetzt
werden kann. Diese Veränderung fällt nicht auf und ermöglicht es, Nachrichten zu übertragen, ohne dass
ein Dritter es überhaupt bemerkt.
In diesem Übungsbeispiel soll ein verstecktes Bild im gegebenen Bild mittels Verschiebung einiger Bits
und Zuordnung von Farbwerten aus einer Tabelle rekonstruiert werden. Weiters soll der im Bild enthaltene
Text segmentiert werden, wofür eine Grauwertkonvertierung und zwei Schwellwerte benötigt werden.
2.1 Aufgabenstellung
Rekonstruktion des versteckten Bildes (2 Punkte) Es gibt mehrere Möglichkeiten, Informationen in
digitalen Bildern zu verstecken. Für die Kodierung des gegebenen Bildes wurde das LSB-Verfahren verwendet,
bei dem eine bestimmte Anzahl der niederwertigsten Bits (bitshift) jedes Farbkanals für die
2

Abbildung 1: Beispielhafte Rekonstruktion eines Pixels für 2 LSB (least significant bits) pro Farbkanal.
Zusatzinformation verwendet werden. Diese Bits werden dann in der Reihenfolge B-G-R zusammengesetzt
und ergeben somit eine einzelne Zahl, den sogenannten Farbindex. Durch Verwendung der Farbtabelle (lookup
table) kann jedem Index ein Farbwert zugeordnet werden. Durch Wiederholung dieser Vorgehensweise
für jedes Pixel entsteht ein Farbbild mit der Größe des gegebenen Bildes. Ein Beispiel ist in Abbildung 1
zu sehen.
Segmentierung mittels Schwellwert (2 Punkte) Aufbauend auf dem Resultat der vorherigen Aufgabenstellung
soll nun mittels eines Schwellwert ein bestimmter Teil des Bildes segmentiert werden. Konvertieren
Sie zunächst das Farbbild in ein Grauwertbild. Verwenden Sie dazu die allgemein übliche Gewichtung
30% Rot, 59% Grün und 11% Blau. Wenden Sie dann die beiden Schwellwerte an, wobei unterer Schwellwert
≤ gesuchter Bereich ≤ oberer Schwellwert ist.
{ 255 lowerthreshold ≤ outputgray_img(x,y) ≤ upperthreshold
outputmask_img(x,y) =
0 else
Das resultierende Binärbild (auch Maske genannt) sollte weiße Bildsegmente auf schwarzem Hintergrund
zeigen. Diese sehr einfache Methode zur Segmentierung kann natürlich nur angewandt werden, wenn sich
die gesuchte Region eindeutig vom Hintergrund abhebt (vergleiche Abbildung 2).
(a) Eingabebild
(b) Rekonstruiertes Bild
(c) Grauwertbild
(d) Maskenbild
Abbildung 2: Eingabebild und Ergebnisbilder von „route66.xml“
3

2.2 Ein- und Ausgabeparameter
Die folgenden Parameter in der Konfigurationsdatei bestimmen das Verhalten des Programms (Anwendungsbeispiele
finden Sie in den Dateien „graz.xml“ und „route66.xml“):
• Input-Bild: input
• Output-Farbbild: outputrgb
• Output-Grauwertbild: outputgray
• Output-Maskenbild: outputmask
• Tabelle zur Farbzuweisung (LUT): colormap
• Anzahl der verwendeten Bits (LSB) pro Farbkanal: bitshift
• Unterer Schwellwert zur Segmentierung: lowerthreshold
• Oberer Schwellwert zur Segmentierung: upperthreshold
2.3 Programmgerüst
Die folgende Funktionalität ist in dem vom ICG zur Verfügung gestellten Programmgerüst bereits implementiert
und muss von Ihnen nicht selbst programmiert werden:
• Die Konfigurationsdatei (XML) wird vom Programmgerüst gelesen.
• Lesen des Eingabebildes.
• Schreiben der Ausgabebilder.
Sie müssen die in der Variable bitshift angegebenen LSB in eine passende Bitmaske konvertieren, um
aus jedem Farbkanal die least significant bits auslesen zu können. Dann müssen Sie daraus indexed_color
erstellen und dann mit Hilfe der indexed_color aus der colormap (LUT) die passende Farbe in das
image_out schreiben. Anschließend erfolgt die Grauwertkonvertierung mit den gegebenen Gewichten
der Farbkanäle in das Bild image_out_gray. Danach müssen Sie unter Verwendung der beiden
Schwellwerte lowerthreshold und upperthreshold das image_out_mask erstellen.
Diese Aufgabe ist mit Hilfe von OpenCV 1 zu implementieren. Nutzen Sie die Funktionen, die Ihnen
OpenCV zur Verfügung stellt und achten Sie auf die unterschiedlichen Parameter!
3 Steerable Filters („cv/task1b“)
In diesem Beispiel sollen Sie einfache Filteroperationen eines Bildes mit verschiedenen Faltungskernen
implementieren. Das Ziel bei dieser Übung ist Ihnen die Faltung sowohl im Bild-, als auch im Frequenzbereich
verständlich zu machen und ein Anwendungsbeispiel von steuerbaren Filtern aufzuzeigen.
Steuerbare Filter kommen oft dann zum Einsatz, wenn es darum geht die Filterantwort eines Faltungskernes
in vielen verschiedenen Orientierungen auszuwerten. Hier gibt es nun zwei mögliche Varianten dies
durchzuführen: Die erste Variante ist das Bild mit verschieden orientierten Kernen zu falten, was bei vielen
Orientierungen aber extrem rechenaufwändig wird. Die weitaus effektivere Variante ist das Bild mit nur
wenigen Faltungskernen zu falten und aus diesen die Antworten der anderen Orientierungen zu interpolieren.
Dies wird in Abbildung 3 veranschaulicht.
1 http://opencv.willowgarage.com
4

Abbildung 3: Blockdiagramm eines steuerbaren Filters. Das Bild wird mit ausgesuchten Orientierungen
eines Filterkerns gefalten. Deren Antworten werden über Koeffizienten linear kombiniert, um die Orientierung
des synthetisierten Filters zu kontrollieren. [FA91]
Somit kann man sich - insofern der Faltungskern gewisse Steuerbarkeitskriterien erfüllt (siehe [FA91]) -
viele Faltungen sparen und alle möglichen Filterantworten über Linearkombination der Antworten der Basisfilter
interpolieren.
3.1 Convolution und Correlation
Wenn man in der Computer Vision von einer Convolution oder Faltung spricht, so wird in der Praxis oftmals
eine Correlation gemeint. Dies kommt daher, dass bei einer Convolution und einer Correlation dasselbe
Ergebnis erzielt wird, wenn ein isotroper beziehungsweise ein rotationsinvarianter Faltungskern zum
Einsatz kommt. Sehen wir uns dazu kurz die mathematischen Definitionen der beiden Verfahren für den
zweidimensionalen Fall an, wobei F für den N × N großen Faltungskern und I(x, y) für einen Bildpunkt
stehen und N stets ungerade sein muss:
F ◦ I(x, y) =
F ∗ I(x, y) =
N−1
2∑
j=− N−1
2
N−1
2∑
j=− N−1
2
N−1
2∑
i=− N−1
2
N−1
2∑
i=− N−1
2
F (i, j)I(x + i, y + j) (1)
F (i, j)I(x − i, y − j) (2)
Formel 1 definiert die Correlation und Formel 2 die Convolution. Was uns hier nun auffallen sollte, sind
die unterschiedlichen Vorzeichen beim Zugriff auf die Bildpunkte während die Faltungsmaske durchiteriert
wird. Wo bei der Correlation stets auf den Pixelwert des Bildes direkt unter dem aktuellen Punkt in der
Maske zugegriffen wird, greift man bei der Convolution auf den um die x- und y-Achse gespiegelten Wert
im Bild zu.
Wichtig für diese Übung ist, dass wenn wir hier von einer Convolution oder Faltung sprechen stets auch
eine solche meinen und keine Correlation! Als kleiner Hinweis sei hier gesagt, dass man durch einfaches
Spiegeln des Faltungskernes um die x- und y-Achse mit einer Methode die normalerweise eine Correlation
berechnet, eine Convolution berechnen kann.
Verwenden wir den Faltungskern
⎡
a b
⎤
c
F = ⎣d e f⎦ ,
g h i
so kann man anhand der folgenden Grafik 4 die Unterschiede der beiden Verfahren gut erkennen.
5

(a) Correlation
(b) Convolution
Abbildung 4: In den beiden Bildern kann man unter Verwendung desselben Faltungskerns F die Unterschiede
der beiden Verfahren Correlation und Convolution deutlich erkennen.
3.2 Aufgaben
Das Beispiel ist in mehrere Unteraufgaben gegliedert, wobei jede Unteraufgabe auf der vorherigen aufbaut.
Der prinzipielle Bearbeitungsablauf besteht aus folgenden Schritten:
• Einlesen und Konvertieren des Eingangsbildes
• Berechnen der Faltungskerne G x und G y für die erste Ableitung des Gaußkerns in x- und y-Richtung
• Faltung des Eingangsbildes mit G x im Bildbereich
• Faltung des Eingangsbildes mit G y im Frequenzbereich
• Interpolation der Filterantworten für verschiedene Orientierungen, Finden der dominanten Orientierung
via max pooling und Darstellung der dominanten Orientierung in sogenannter orientation
map
• Einzeichnen der dominanten Orientierung im Eingangsbild
Einlesen und Konvertieren des Eingangsbildes Sie bekommen von uns stets Grauwertbilder für diese
Aufgabe (siehe zum Beispiel Abbildung 5). Das Einlesen des Bildes ist bereits erledigt. Für Sie gilt es
nunmehr das Bild vom Grauwertebereich [min_gray_val,max_gray_val] linear auf Werte zwischen [0,1]
zu konvertieren, so dass der gesamte Bereich [0,1] ausgenutzt wird.
Hier hilfreiche OpenCV-Befehle:
• cv::minMaxLoc(...)
• cv::Mat::convertTo(...)
Berechnen der Faltungskerne G x und G y für die erste Ableitung des Gaußkerns Die Gaußfunktion
(siehe Abbildung 6(a)) ist definiert als
G = e − 1 (x 2 +y 2 )
2 σ 2 (3)
6

Abbildung 5: Eingangsbild
und somit ergeben sich die Ableitung G x (siehe 6(b)) in x-Richtung und die Ableitung G y (siehe 6(c)) in
y-Richtung wie folgt:
G x = − x σ 2 · 1 (x 2 +y 2 )
e− 2 σ 2 (4)
G y = − y σ 2 · 1 (x 2 +y 2 )
e− 2 σ 2 (5)
Verwenden Sie die Parameter σ = in_sigma und N = in_window_size und befüllen Sie die G x und
G y jeweils N ×N großen Faltungskerne entsprechend Ihrer mathematischen Definition. Die Faltungskerne
sollen in der Maske zentriert und somit mittelwertfrei sein. Abschließend normalisieren Sie jeden der Kerne
so, dass für zum Beispiel für G x folgendes gilt:
N−1
2∑
j=− N−1
2
N−1
2∑
i=− N−1
2
(6)
|G x (i, j)| = 1 (7)
Faltung des Eingangsbildes mit Gx im Bildbereich (2 Punkte) Nun falten Sie das Eingangsbild mit
G x im Bildbereich. Achten Sie dabei darauf, dass Sie, wie weiter oben beschrieben, eine Convolution und
keine Correlation durchführen!
Da der Faltungskern an den Bildrändern um bis zu (N − 1)/2 Pixel über den Bildrand hinausragt ist eine
Randbehandlung nötig, um die anfängliche Bildgröße beizubehalten. Wiederholen Sie dazu die Randpixel
dementsprechend oft, wie in Abbildung 7 skizziert.
Abschließend speichern Sie das Ergebnis der Filterung unter out_x_derivative_filename. Bringen
Sie dazu das Bild, das Sie speichern wieder linear auf einen Wertebereich zwischen [0,255], so dass
auch hier der gesamte Bereich ausgenutzt wird. Achten Sie aber gleichzeitig darauf mit dem vorhergehenden
Ergebnis weiterzurechnen!
Weitere hilfreiche OpenCV-Befehle:
• cv::flip(...)
• cv::filter2D(...)
7

(a) G
(b) G x
(c) G y
Abbildung 6: In den 3 Bildern kann man den Gausskern und dessen x- und y-Ableitung sehen. Links jeweils
die 3D-Ansicht und rechts die Betrachtung von oben.
8

Abbildung 7: Randbehandlung durch Wiederholung der Randpixel: blau: Faltugnskern mit N = 5,
schwarz: Bild, grau: (N − 1)/2 Pixel breiter Rand
Abbildung 8: Eingangsbild gefaltet mit G x
Faltung des Eingangsbildes mit Gy im Frequenzbereich (4 Punkte) Falten Sie das Eingangsbild mit
G y im Frequenzbereich. Dazu müssen Sie das Bild sowie den Faltungskern zuerst vom Bild- mittels Fouriertransformation
in den Frequenzbereich transformieren. Das Faltungstheorem 8 besagt, dass eine Faltung
im Bildbereich einer Multiplikation im Frequenzbereich gleich kommt. Somit können Sie Bild und Kern
nun punktweise miteinander multiplizieren und abschließend auf das Ergebnis die inverse Fouriertransformation
anwenden.
F{(i ∗ f)(x, y)} = I(x, y)F (x, y) (8)
Bevor Sie das Eingangsbild jedoch in den Frequenzbereich transformieren, müssen Sie sich noch im Bildbereich
um die Randbehandlung kümmern. Auch hier verwenden Sie wiederum die in Abbildung 7 beschriebene
Art der Randbehandlung und wiederholen den äußeren Rand.
Da die Fouriertransformation für Bildgrößen die einer Potenz von 2, oder dem Produkt von 2, 3 und 5 entsprechen
effizient implementiert werden kann, verwenden Sie bitte die Funktion cv::getOptimalDFTSize(...)
zum berechnen der optimalen Bildgröße. Anschließend erzeugen Sie sowohl für das randbehandelte Eingangsbild,
als auch für den Faltungskern zwei dementsprechend große Bilder. Da diese nun größer sind,
als die tatsächlichen Bilder, müssen Sie sowohl das randbehandelte Bild, als auch den Faltungskern in
das linke obere Eck der vergrößerten Bilder kopieren (vergleiche Abbildung 9). Nun können beide Bilder
fouriertransformiert werden. Haben Sie beide Bilder im Frequenzbereich vorliegen, so können Sie die Faltung
durch punktweise Multiplikation durchführen. Achten Sie darauf, dass durch die Transformation nun
komplexe Zahlenwerte vorliegen!
9

Abbildung 9: Einlesen des Eingangsbildes in ein größeres Bild, bei dem die Bildgröße eine effizientere
Ausführung der Fouriertransformation erlaubt
Lassen Sie sich nun den Amplitudengang des komplexen Fourierspektrums mittels der mitgelieferten Funktion
shiftdft(...) berechnen, die den Ursprung in die Bildmitte bringt und die 4 Quadranten richtig anordnet.
Die Funktion shiftdft(...) besitzt als Argumente zwei Bilder, wobei das erste Bild ein 2-Kanalbild sein muss.
Im Kanal 1 muss der Real- und im Kanal 2 der Imaginärteil Ihrer Multiplikation im Frequenzbereich stehen.
Im zweiten Argument übergeben Sie ein leeres Bild derselben Größe mit nur 1 Kanal. In dieses wird
das Ergebnis von shiftdft(...) geschrieben. Das Ergebnis ist in Abbildung 10 dargestellt.
Abbildung 10: Fourierspektrum des Ergebnisses der Faltung dargestellt mit Hilfe von shiftdft(...)
Speichern Sie das Ergebnisbild unter out_magnitude_filename ab. Vor dem Abspeichern des Bildes
sollte dieses natürlich wieder auf den gesamten Wertebereich zwischen [0,255] linear aufskaliert werden.
Nach der Multiplikation im Frequenzbereich müssen Sie das Ergebnis mittels inverser Fouriertransformation
wieder zurück in den Bildbereich bringen. Achten Sie dabei sowohl auf die richtige Skalierung, als
auch darauf, dass Ihr Ergebnis nicht complex ist! Weiters müssen Sie aus dem Ergebnis der inversen Transformation
nun unter Anwendung der Randbehandlung wieder ein Bild richtiger Größe, nämlich derselben
Größe, wie jene des Eingangsbildes, beginnend bei [N − 1, N − 1] ausschneiden (siehe Abbildung 11).
10

Speichern Sie das gefilterte Ergebnisbild unter out_y_derivative_filename. Skalieren Sie das
Bild, das Sie speichern wollen wiederum auf den Wertebereich [0,255] und achten Sie gleichzeitig darauf
mit dem vorhergehenden Ergebnis weiterzurechnen!
Abbildung 11: Eingangsbild gefaltet mit G y
Hinweis: Sollten Sie nicht in der Lage sein diesen Punkt auszuprogrammieren, so falten Sie das Bild mit
G y im Bildbereich, um fortfahren zu können. Sie bekommen dann aber für diese Teilaufgabe keine Punkte!
Weitere hilfreiche OpenCV-Befehle:
• cv::copyMakeBorder(...)
• cv::Mat::copyTo(...)
• cv::merge(...)
• cv::dft(...)
• cv::split(...)
• cv::Rect(...)
Interpolation der Filterantworten für verschiedene Orientierungen, Finden der dominanten Orientierung
via max pooling und Darstellung der dominanten Orientierung in sogenannter orientation
map (4 Punkte) Da die erste Ableitung des Gausskerns die Steuerbarkeitskriterien erfüllt, kann mit nur
2 Basisfiltern jede beliebige Orientierung der ersten Ableitung des Gausskerns G θ◦
1 wie folgt interpoliert
werden:
G θ◦
1 = cos (θ)G 0◦
1 + sin (θ)G 90◦
1
= cos (θ)G x + sin (θ)G y (9)
Weiters kommt uns zu Gute, dass die Faltung eine lineare Operation darstellt. Somit kann auch jedes Bild,
welches mit einem Kern bestimmter Orientierung gefalten werden soll, direkt über die mit den 2 Basisfiltern
bereits gefilterten Bilder interpoliert werden. Das bedeutet für Sie, dass Sie nicht zuerst einen Filterkern
von zum Beispiel G 135◦
1 erzeugen und dann das Bild mit diesem falten müssen, sondern, dass Sie das
11

Ergebnis direkt aus den bereits mit G x und G y gefilterten Versionen des Bildes durch Linearkombinieren
der beiden Bilder erhalten. Somit benötigen wir lediglich 2 Faltungen
I x = G x ∗ I (10)
I y = G y ∗ I (11)
und können nun jedes Bild gefalten mit einem G 1 -Kern beliebiger Orientierung θ erzeugen aus
I θ◦
1 = cos (θ)I x + sin (θ)I y (12)
Erzeugen Sie nun zwischen −90 ◦ ≤ θ < 90 ◦ in 1 ◦ -Schritten die Filterantworten für die jeweilige Orientierung
des mit G θ◦
1 gefaltenen Bildes. Nun machen Sie ein max pooling indem Sie sich für jedes Pixel sowohl
die dominante Orientierung, als auch die Amplitude der zugehörigen Filterantwort merken (Hinweis: Es
ist egal, ob die Filterantwort positiv oder negativ ist. Es geht um den Absolutwert!). Abschließend konvertieren
Sie die Amplituden der Filterantworten linear auf einen Wertebereich zwischen [0,1]. Speicher
Sie dieses Bild unter out_max_response_filename ab (verlgeiche Abbildung 12), nachdem Sie es
wieder auf den vollen Wertebereich von [0,255] gebracht haben.
Abbildung 12: Maximale Filterantwort pro Pixel
Nun sollen Sie eine Orientation-Map generieren, indem Sie die Orientierung und die Amplitude jedes
Pixels als HSV-Farbwert in ein RGB-Farbbild kodieren. Dazu sehen Sie den HSV-Farbraum in Abbildung
13. Die Orientierungen zwischen −90 ◦ ≤ θ < 90 ◦ kodieren wir im HSV-Farbraum nun von 0 ◦ ≤ hue <
180 ◦ und die Amplitude der Filterantwort von 0 ≤ saturation ≤ 1. Da wir den value-Wert nicht benötigen
setzen wir diesen auf value = 1.
Gegeben sei eine Farbe mit hue H ∈ [0 ◦ , 360 ◦ ) und saturation S ∈ [0, 1]. Um nun ein RGB-Bild zu
generieren wenden Sie folgende HSV-RGB-Farbkonvertierung nach den Formeln 13, 14, 15 und 16 an:
(K, L, M) =
H ′ H
=
60
(13)
◦
X = S · (1 − |mod2 (H ′ , 2) − 1|) (14)
⎧
⎪⎨
⎪⎩
(S, X, 0) if 0 ≤ H ′ < 1
(X, S, 0) if 1 ≤ H ′ < 2
(0, S, X) if 2 ≤ H ′ < 3
(0, X, S) if 3 ≤ H ′ < 4
(X, 0, S) if 4 ≤ H ′ < 5
(S, 0, X) if 5 ≤ H ′ < 6
(R, G, B) = (K + (1 − S), L + (1 − S), M + (1 − S)) (16)
(15)
12

(a) HSV Zylinder
(b) HSV-RGB
Abbildung 13: In den beiden Abbildungen sind sowohl der Aufbau des HSV-Farbraumes, als auch die
Umwandlung HSV-RGB dargestellt (Bildquelle: http://en.wikipedia.org)
Speichern Sie die farbige Orientation-Map nun unter out_orientation_map_filename ab. Achten
Sie bitte darauf, dass bei OpenCV die Farbkanalreihenfolge nicht RGB, sondern BGR ist (vergleiche
Abbildung 14)!
Abbildung 14: Orientation-Map: maximale Orientierung und Stärke sind HSV-farbkodiert
Einzeichnen der dominanten Orientierung im Eingangsbild (2 Punkte) In diesem Punkt gilt es nun
anhand der bereits berechneten, lokal dominanten Orientierungen eine einzige Hauptorientierung für das
Bild zu berechnen. Dies geschieht indem Sie ein gewichtetes Histogramm über alle Orientierungen generieren,
welches alle Filterantworten der jeweiligen lokal dominanten Orientierung aufsummiert. Anschließend
Suchen Sie ausgehend von −90 ◦ das erste Maximum des Histogramms und haben somit die Hauptrichtung
gefunden.
Erzeugen Sie sich die gefilterte Variante des Eingangsbildes entlang der Hauptrichtung über eine Linearkombination
der mit G x und G y gefaltenen Bilder, wie in Formel 12 beschrieben. Nun erstellen Sie sich
ein Binärbild indem Sie die gefilterte Version mit in_threshold schwellwerten (vergleiche Abbildung
15). Speichern Sie das Binärbild unter out_threshold_filename ab!
Abschließend erzeugen Sie ein 3-Kanalbild, welches das Eingangsbild (Grauwertbild) enthält, und markieren
in diesem jene Pixel in rot ( (R,G,B) = (255,0,0) ), die im Schwellwertbild angeschlagen haben, aber
maximal um ±10 ◦ von der dominanten Hauptrichtung abweichen (vergleiche Abbildung 16). Speichern
Sie das Ergebnisbild unter out_result_filename.
13

Abbildung 15: Binäres Schwellwertbild durch Faltung des Eingangsbildes entlang der dominanten Orientierung
und anschließendem Schwellwerten
Abbildung 16: Endergebnis: Markieren der Hauptrichtung im Eingangsbild
Weitere hilfreiche OpenCV-Befehle:
• cv::threshold(...)
3.3 Ein- und Ausgabeparameter
Die folgenden Parameter in der Konfigurationsdatei bestimmen das Verhalten des Programms (Anwendungsbeispiele
finden Sie in der Datei „test.xml“):
• Eingabe - Bild: in_filename
• Parameter - Faltungskern N × N mit N: in_window_size
• Parameter - Faltungskern σ: in_sigma
• Parameter - Threshold t: in_threshold
14

• Ausgabe - Ergebnisbild der Faltung mit G x : out_x_derivative_filename
• Ausgabe - Amplitudengang der Faltung mit G y im Frequenzbereich: out_magnitude_filename
• Ausgabe - Ergebnisbild der Faltung mit G y : out_y_derivative_filename
• Ausgabe - Orientation Map: out_orientation_map_filename
• Ausgabe - Binäres Thresholdbild: out_threshold_filename
• Ausgabe - Ergebnisbild: out_result_filename
3.4 Programmgerüst
Die folgende Funktionalität ist in dem vom ICG zur Verfügung gestellten Programmgerüst bereits implementiert
und muss von Ihnen nicht selbst programmiert werden:
• Die Konfigurationsdatei (XML) wird vom Programmgerüst gelesen.
• Lesen des Eingabebildes
• Für jeden Unterpunkt der Aufgabenstellung werden in main() entsprechende Bilder mit den in der
Konfigurationsdatei spezifizierten Namen abgespeichert. Zur Zeit werden hier nur leere Bilder abgespeichert.
Diese sind von Ihnen durch Ihre Ergebnisbilder zu ersetzen. Diese Ausgabebilder werden
später verwendet, um die einzelnen Teilaufgaben zu bewerten. Sollten Sie einen Punkt nicht ausprogrammieren,
so achten Sie bitte darauf, dass trotzdem ein Bild entsprechender Größe abgespeichert
wird, da diese zum automatischen Testen benötigt werden.
• In main.cpp ist eine Funktion shiftdft() zum korrekten Darstellen des Amplitudengangs im
Frequenzbereich ausimplementiert. Sollten Sie diese Methode zu Testzwecken verändern, so sollten
Sie diese vor Abgabe unbedingt in Ihre Ursprungsform zurückbringen, da sonst das automatische
Testen beeinträchtigt werden kann.
Auch diese Aufgabe ist mit Hilfe von OpenCV 2 zu implementieren. Nutzen Sie die Funktionen, die
Ihnen OpenCV zur Verfügung stellt und achten Sie auf die unterschiedlichen Parameter!
2 http://opencv.willowgarage.com
15

(a) TU Logo
(b) Die
Abbildung 17: Ray-Casting Beispiele: Das TU Graz Logo bestehend aus Dreiecken (Abbildung 17(a)), ein
Würfel bestehend aus Dreiecken und Kugeln (Abbildung 17(b)).
4 Ray-Casting („CG/task1a“)
Ray-Casting ist ein bildbasiertes Darstellungssverfahren für 3 dimensionale Objekte. Das Verfahren bestimmt
pixelweise die Sichtbarkeit der Szene-Elemente und sendet dafür für jeden Pixel ein Blickstrahl
oder Ray vom Ursprungspunkt („Augpunkt“/„Origin“) in die Szene. Ein solcher Strahl entspricht einer
geraden Linie vom Ursprungspunkt durch einen Pixel in die Szene. Wie in Abbildung 18 illustriert, werden
für jeden Strahl alle Schnittpunkte mit den Objekten der Szene berechnet. Zur Berechnung der Pixelfarbe
wird im Anschluss jener Schnittpunkt herangezogen, der dem Betrachter am nächsten liegt. Ray-Casting
wird als Spezifallfall des „Ray-Tracing“ Verfahrens angesehen. Im Vergleich zum klassischen Ray-Tracer
verzichtet ein Ray-Caster auf Reflexionen und Transparenz [HB04][Kapitel 10.11].
Abbildung 18: Erster Schnittpunkt wird zur Berechnung der Pixelfarbe benutzt; die verdeckten Objekte
werden am Bildschirm nicht gezeigt.
4.1 Aufgaben
In dieser Übung ist ein Sichtstrahl vom Augpunkt durch jeden Bildpunkt einer Bildebene („View-Plane“)
zu erstellen. Danach werden alle Schnittpunkte mit den Dreiecken und Kugeln der Szene berechnet und derjenige
ausgewählt der dem Betrachter am nächsten liegt. Um eine 3 dimensionale Darstellung zu erzielen,
werden die Farbwerte an den Schnittpunkten im Anschluss schattiert. Zum Testen der Strahlenberechnung
sind im Framework die Berechnungen zur Schattierung sowie die Schnittberechnung für Kugeln bereits
implementiert. Zur Fertigstellung der Aufgabe ist daher nur noch die Erstellung und das Aussenden der
Sichtstrahlen sowie die Schnittberechnungen der Strahlen mit den Dreiecken der Szenen zu implementieren.
16

Abbildung 19: Augpunkt und Sichtstrahlen durch die Pixel an den Ecken der Bildebene. Pixelkoordinaten
sind in grün, View Plane Koordinaten in weiß und schwarz eingezeichnet. Die Entfernung zwischen View
Plane und Augpunkt ist f
.
Erstellen und Aussenden der Rays (3 Punkte) Wie in Abbildung 19 dargestellt, hat die Bildebene
(„View Plane“) eine fixierte Ausdehnung im World Space, die unabhängig von der Anzahl der Pixel ist.
Dies ist nötig, um zu verhindern, dass z.B. ein Bild mit geringerer Auflösung weniger von der Szene darstellt.
Die Position (−1/aspect, 1) entspricht der linken oberen Ecke der View Plane, und damit auch der
linken oberen Ecke des Pixels (0, 0). Der Parameter aspect sei hier das Verhältnis Hoehe/Breite des
Ausgabebildes und ist durch dessen Dimensionen bereits vorgegeben. Ihre Aufgabe ist es, in der Methode
calculateImage der Klasse RayCaster einen Strahl zu erstellen, der vom Augpunkt durch den
Mittelpunkt des zu untersuchenden Pixels läuft.
Ein n-dimensionaler Vektorraum kann durch n Einheitsvektoren, die zueinander normal stehen, beschrieben
werden. Im Fall des Ray-Castings handelt es sich um einen dreidimensionalen Raum, der üblicherweise
durch die drei euklidischen Einheitsvektoren (oder auch „Achsen“) x, y, z beschrieben wird. Das verwendete
Koordinatensystem sieht folgende Richtungen vor: x = Horizontale, y = V ertikale, z = T iefe.
Man unterscheidet hier zwischen Welt- und Sichtkoordinatensystem - „World Space“ und „View Space“.
Objekte werden in Weltkoordinaten platziert und durch die kanonischen Einheitsvektoren beschrieben. Der
Augpunkt („Origin“) und somit die Kamera kann allerdings an einer beliebigen Position platziert sein und
eine beliebige Ausrichtung haben. Dadurch können die Koordinatenachsen der Kamera ungleich denen des
Weltkoordinatensystems werden. Beispielsweise ist der z-Vektor der Kamera in Abbildung 20 ungleich
dem z-Vektor des Weltkoordinatensystems
⎛
SightVector = ⎝
2
−1
0
⎞
⎛
⎠, normalisiert ⎝
⎞ 2√
5
√−1
⎠
5
0
Da die Kameraposition in World Space Koordinaten vorliegt, lassen sich mit den transformierten Einheitsvektoren
alle Strahlen durch die einzelnen Pixel in Weltkoordinaten beschreiben. Die benötigten Parameter
werden im Programm übergeben wobei die euklidischen Einheitsvektoren bereits berechnet sind. Sie müssen
also nicht mehr verändert, sondern nur für die Erstellung der Sichtstrahlen benutzt werden.
17

Abbildung 20: Achsen des Worldspace (x, y, z) und z-Achse aus Kamerasicht (SightV ector)
Es existiert bereits eine verschachtelte for-Schleife, die für Sie die Pixel des Ausgabebildes durchläuft.
Die aktuelle Pixelposition wird durch das Paar (pixel_x, pixel_y) beschrieben. Konvertieren Sie also
die horizontale Pixelposition pixel_x, im Bereich zwischen 0 und dim_x, zu einem horizontalen Abstand
viewplane x mit einem Wert zwischen −1/aspect und 1/aspect, und speichern Sie das Ergebnis als
Fließkommazahl. Die vertikale Pixelposition pixel_y soll zu einem Wert viewplane y zwischen 1 und −1
konvertiert werden. Beachten Sie bei beiden, dass der Strahl durch den Mittelpunkt der Pixel geschossen
werden soll!
Wenn sie diese Werte viewplane x und viewplane y für den aktuellen Pixel berechnet haben, muss nur
mehr der Strahl erstellt werden. Verwenden sie dafür eine float3 und die nachfolgende Formel
ray = viewplane x · x + viewplane y · y + f_z (17)
Das Ergebnis muss noch normalisiert werden, da die verwendeten Formeln zur Schnittberechnung sonst
ungültig sind. Rufen Sie danach die Methode shootRay mit der Startposition camera.eye, dem berechneten
Strahl, der Objektliste shapes, der Lichtquelle light und dem Farbwert pixel_color auf.
Wenn die Methode true retourniert, wurde ein Objekt getroffen und dessen Farbwert ist in pixel_color
gespeichert. Sie können daraufhin einen Pixelwert R8G8B8A8 mit der berechneten pixel_color erstellen.
Die Pixel können mit output_image_(pixel_x, pixel_y) addressiert werden.
Schnitt mit Dreiecken (3 Punkte) Überschreiben Sie die Methode findIntersectionPoints der
Klasse Triangle, um die Kontrolle der Schnittpunkte für Dreiecke zu aktivieren. Als erstes muss der
Schnittpunkt mit der Ebene gefunden werden, die von dem zu testenden Dreieck aufgespannt wird. Benutzen
Sie dazu die Methode MathUtils::rayPlaneIntersect. Als Parameter müssen der Startpunkt
und der Vektor des Rays, sowie die Instanzattribute face_.plane_D und face_.normal_vector
übergeben werden. Bei einem normalisierten Ray ist der Returnwert s der Funktion die Distanz zwischen
Schnittpunkt auf der Ebene und Startpunkt. Sollte diese Distanz

Abbildung 21: Problematik der Unterscheidung bei Punkten zwischen Inliern und Outlieren
Nun muss eine Technik angewandt werden, um die Inlier von den Outliern (die Punkte innerhalb von denen
au¨sserhalb des Dreiecks) zu unterscheiden. Dafür existieren verschiedenste Algorithmen mit unterschiedlicher
Rechenzeit im dreidimensionalen Raum. Von Ihnen soll ein Algorithmus umgesetzt werden der die
Eigenschaften von Kreuzprodukt und Normalvektoren ausnutzt.
(a) (0, 1, 0) × (1, 0, 0) (b) (1, 0, 0) × (0, 1, 0)
Abbildung 22: Die Illustrationen in (a) und (b) zeigen die unterschiedlichen Ergebnisse für Normalvektoren,
abhängig von Reihenfolge und Orientierung der verwendeten Vektoren im Kreuzprodukt
Bei dieser Methode wird überprüft, ob der Punkt P auf der gleichen Seite einer Kante (zwischen zwei
Punkten des Dreiecks) liegt wie der verbleibende dritte Punkt. Dies wird für alle Kanten überprüft. Anfangs
wird der Normalvektor n des Dreiecks durch −→ −→
−→
AB × AC gebildet. Sei nun AP der Vektor von Punkt A zum
gefunden Schnittpunkt Punkt P . Der Normalvektor n a sei nun das Ergebnis von −→ −→ AB × AP . Ist nun das
Skalarprodukt 〈n a , n〉 >= 0, liegt P auf der gleichen Seite von −→ AB wie C und der Test für diese Kante war
erfolgreich.
Der Vektor n wurde für Sie bereits vorberechnet und ist als Instanzattribut face_.normal_vector
verfügbar. Es gilt also für jede Kante x den Normalvektor n x zu berechnen. Die Punkte eines Dreiecks
befinden sich in dem Instanzarray vertices_. Die Berechnung des Normalvektors n x soll stets mit
n x = (vertices_[x + 1] − vertices_[x]) × (P − vertices_[x]) (19)
durchgeführt werden. Berücksichtigen Sie dabei auch die Kante vertices_[0] − vertices_[2].
War der Test für alle Seiten erfolgreich, wird nur mehr die IntersectionInfo geupdated.
Finden des ersten Schnittpunktes Die schnellstmögliche Methode den relevanten Schnittpunkt zu erhalten,
besteht darin schon während der Schnittpunktberechnung der Objekte die Ergebnisse mit den bisherigen
Schnittpunkten zu vergleichen. Das Struct IntersectionInfo soll immer den Schnittpunkt
19

enthalten, welcher der Kamera momentan am nächsten ist, solange bis alle Objekte durchlaufen wurden.
Das Struct enthält folgende Attribute, die von Ihnen über die Methode updateIntersectionInfo
bei jedem relevanten Schnittpunkt aktualisiert werden sollen:
• found: Wird automatisch true wenn die Instanzmethode updateIntersectionInfo aufgerufen
wird.
• min_dist: Die Entfernung des Schnittpunktes von der Kamera. Da der Strahl normalisiert ist,
entspricht s in den oberen Formeln direkt der Distanz von der Kamera.
• intersection: Der näheste Schnittpunkt in World Space Koordinaten.
• normal_vector: Der Normalvektor der Oberfläche an der Stelle des Schnittpunktes wird für die
Beleuchtung benötigt. Aus den Algorithmen sollte hervorgehen, wie Sie diesen beim Schnittpunkttest
erhalten können.
• color: Der Farbwert des Objektes. Ableitungen der Klasse Shape enthalten den Farbwert als
Instanzattribut color_.
4.2 Vektorklasse
Für die schnelle Berechnung von Vektorergebnissen wurde eine eigene Vektorklasse erstellt. Es existieren
verschiedene Templates, von Ihnen soll aber nur float3 verwendet werden. Verwenden Sie diese Klasse
für Punkte und Vektoren im dreidimensionalen Raum. Die Klasse besitzt die Attribute x,y,z, welche die
Bewegung des Vektors/Position des Punktes darstellen. Eine float3 kann normalisiert werden durch die
Instanzmethode VEKTORNAME.normalize. Alternativ erhalten Sie mit normalize(float3&) eine
normalisierte Kopie eines Vektors als Rückgabewert, ohne den Originalvektor zu verändern.
Um das Skalarprodukt zweier Vektoren in Form einer Fließkommazahl zu erhalten, verwenden Sie
dot(float3&, float3&). Für das Ergebnis des Kreuzprodukts in Form einer float3, verwenden
Sie cross(float3&, float3&). Die Operatoren + und - sind überschrieben, sodass z.B. der Vektor
zwischen den beiden float3-Punkten A und B mit B − A berechnet werden kann. Das Ergebnis ist dann
wiederum eine float3. Die Klassenheader befinden sich zur Einsicht in „CG/common/vector.h“.
4.3 Ein- und Ausgabe
Alle benötigten Paramter werden aus einer Konfigurationsdatei (deren Name als einziges Argument beim
Programmstart angegeben wird) gelesen. Da Ray-Casting zeitlich aufwändig ist, werden während dem
Programm Statusmeldungen ausgegeben. Das Ausgabebild befindet sich nach erfolgreichem Beenden in
„output/TESTCASENAME.png“.
4.4 Programmgerüst
Das zur Verfügung gestellte Programmgerüst implementiert bereits die komplette Infrastruktur (Konfigurationsdatei
lesen und interpretieren, Ausgabebild speichern, Beleuchtung und Schnittpunktetests für Kugeln)
Für die Implementierung wichtige Parameter sind:
• Camera: Enthält die Parameter für die Berechnung der Einheitsvektoren und die Position eye.
• Surface: Das Surface output_image_ ist ein Attribut der Klasse RayCaster und enthält die
Farbwerte für den Output. Pixel können über output_image_(pixel_x, pixel_y) addressiert
werden und Farbwerte im Format R8G8B8A8 zugewiesen bekommen. Benutzen Sie dafür den
Konstruktor R8G8B8A8(float3&) und übergeben Sie die berechnete pixel_color.
Für die Vektorberechnungen soll ausschließlich die Klasse float3 verwendet werden, für Kommazahlen
ausschließlich float.
20

Wichtige Methoden
• calculateImage: Zu finden in der Datei „RayCaster.cpp“. Hier muss der Strahl für jeden
einzelnen Pixel berechnet, abgeschossen und das Ausgabebild bei einem Treffer mit der Ergebnisfarbe
geupdated werden.
• findIntersectionPoints: Muss in dem File „Triangle.cpp“ ergänzt werden. In dieser
Methode soll der angegebene Algorithmus umgesetzt werden, wobei darauf zu achten ist, dass nur
relevante Punkte (der Kamera nähere) in das Struct IntersectionInfo geschrieben werden.
Verwenden sie dafür die Instanzmethode updateIntersectionInfo.
• shootRay: Zu finden in der Datei „RayCaster.cpp“. Hier werden bereits alle Objekte der Szene
durchlaufen und auf Schnittpunkte überprüft. Zu ergänzen ist hier nichts.
4.5 Q&A
Q: Eine float3 kann ein Punkt und ein Vektor sein? Wie geht das?
A: Alles, was nötig ist um einen Vektor zu beschreiben sind drei Richtungswerte. Ein Punkt ist nichts anderes,
als der Vektor der vom Punkt (0, 0, 0) aus zurückgelegt werden muss um ihn zu erreichen.
Q: Wie funktioniert die View Plane Transformation? Was bedeutet „durch den Mittelpunkt der Pixel“?
A: Zeichnen Sie sich eine 3x3 View Plane auf Papier auf und markieren sie die Ecken so wie in Abbildung
19. Bedenken Sie, dass die linke obere Ecke der View Plane (-1/aspect, 1) auch die linke obere Ecke des
ersten Pixels (0, 0) darstellt. Markieren Sie nun die Mittelpunkte der Pixel und überlegen Sie sich, welche
Anpassungen der Koordinaten nötig sind, um diese Mittelpunkte zu erreichen. Ein Hinweis: die Werte
viewplane x und viewplane y können niemals den Wert der jeweiligen View Plane Ausdehnung haben, da
diese ja den linken/oberen Rand des ersten bzw. rechten/unteren Rand des letzten Pixels anvisieren würden.
Q: Welche Tests sollen in welcher Reihenfolge gemacht werden?
A: Folgende Aufteilung wäre vom Ablauf her zu empfehlen:
a) sphere.xml, colorspheres.xml: Testen das Aussenden der Strahlen mit bereits implementierten Kugeln.
b) screen.xml, aspect.xml, depth.xml, cube.xml, tu.xml: Testen die Schnittpunktfunktion von Dreiecken.
c) triforce.xml, die.xml, solar.xml: Testen die Anwendung von Kugeln und Dreiecken in Kombination.
d) Alles übrige...: Eignet sich um Ihre Implementierung auf kleinere Schwächen zu prüfen.
Q: Ist das denn alles schaffbar?
A: Es wurde hier sehr detailliert auf die einzelnen Schritte eingegangen, um zu verdeutlichen warum die
jeweiligen Berechnungen benötigt und die gegebenen Formeln verwendet werden. Ein Renderingverfahren
ist natürlich mit viel Verständnisarbeit verbunden, beginnen Sie also früh genug. Tatsächlich kommt die
Referenzlösung aber mit 20 LOC (Lines of Code) aus.
21

5 Rasterization („CG/task1b“)
Unter Rasterisierung versteht man den Prozess bei dem graphische Primitive (Linien, Polygone, etc.) in eine
Rastergrafik gewandelt werden. Rasterizer bilden die Grundlage für einen Großteil aller heutigen Computergrafiksysteme,
vor allem im Bereich der Echtzeitgrafik. Zweck dieser Übung ist es mit den Grundlagen
der Rasterisierung sowie dem Konzept einer Grafikpipeline und damit den wesentlichen Abläufen auf
dem Weg von einer dreidimensionalen Szenenbeschreibung zu einem zweidimensionalen Abbild der Szene
vertraut zu werden. Dazu sollen die einzelnen Schritte einer vereinfachten Grafikpipeline implementiert
werden.
Der zu implementierende Rasterizer soll auf Objekte, die aus Dreiecken zusammengefügt sind anwendbar
sein. Dreiecke verfügen über eine Reihe wünschenswerter Eigenschaften die sie zum idealen Kandidaten
für ein graphisches Primitiv machen, zum Beispiel:
• Dreiecke sind als einfachste zweidimensionale Form sehr simpel und effizient zu Rasterisieren.
• Jedes komplexere Polygon lässt sich aus Dreiecken zusammensetzen und auch beliebige räumliche
Flächen können über Dreiecksnetze approximiert werden.
• Ein Dreieck bleibt auch unter einer perspektivischen Projektion immer ein Dreieck (außer in Grenzfällen
wo ein Dreieck zur Linie werden kann).
Aus all diesen Gründen sind Dreiecke die wichtigste Art von Primitiven in der Computergrafik. Praktisch
alle Rasterizer heutzutage arbeiten auf Basis von Dreiecken und auch der im Rahmen dieser Übung entwickelte
soll hier keine Ausnahmen sein.
Eine 3D Szene kann durch eine Liste von Dreiecken (gegeben durch die Positionen ihrer Vertices im Raum),
sowie einigen Kameraparametern (Position, Ausrichtung, etc.) beschrieben werden. Vor der Rasterisierung
müssen die Dreiecke einer Reihe von Koordinatentransformationen unterzogen werden um von den 3D
Positionen zu den 2D Positionen an denen ein Dreieck schlussendlich ins Ausgabebild gezeichnet werden
soll zu gelangen. Abschießend ist noch eine Überprüfung der Sichtbarkeit konkreter Pixel notwendig.
5.1 Aufgaben
Die Übung setzt sich aus den folgenden Schritten zusammen:
Einlesen der Dreieckslisten Die Dreieckslisten und alle anderen benötigten Paramter werden aus einer
Konfigurationsdatei (deren Name als einziges Argument beim Programmstart angegeben wird) gelesen.
Das Format ist identisch zu dem bereits in „CG/task1a“ verwendeten und kann anhand der bereitgestellten
Testcases nachvollzogen werden.
Vertex Tansformation (2 Punkte) Durch homogene Koordinaten lassen sich alle affinen Transformationen
sowie eine perspektivische Projektion über Matrizen beschreiben. Die Position und Ausrichtung der
virtuellen Kamera ist gegeben durch die Kameraposition eye, den Punkt auf den die Kamera gerichtet ist
lookat und einen Richtungsvektor up, der die Rotation der Kamera um die Blickrichtung festlegt. Wie in
Abbildung 23 dargestellt lassen sich aus diesen Parametern sehr einfach die Basisvektoren des Viewspace
berechnen:
cz =
lookat − eye
‖lookat − eye‖
cx =
up × cz
‖up × cz‖
cy = cz × cx (20)
22

up
cy
y
eye
cx
cz
z
lookat
Abbildung 23: Kameramodell
x
Man beachte dass in dieser Übung ein linkshändiges Koordinatensystem verwendet wird. Sind die Basisvektoren
bestimmt ergibt sich die Viewmatrix nach:
⎛
⎞
cx x cx y cx z −〈cx, eye〉
View = ⎜cy x cy y cy z −〈cy, eye〉
⎟
⎝cz x cz y cz z −〈cz, eye〉 ⎠ (21)
0 0 0 1
Auf die Transformation in Kamerakoordinaten durch die Viewmatrix folgt die Transformation in den
Clipspace durch die Projectionmatrix. Die Projektion ist bestimmt durch die Kameraparameter fov, near
und far sowie das Seitenverhältnis aspect = w h
des Ausgabebildes (wobei w die Breite und h die Höhe
bezeichnet):
⎛
⎞
1
0 0 0
aspect·tan( fov
2 )
1
Projection =
0 0 0
tan(
⎜
fov
2 )
far near·far ⎟
(22)
⎝ 0 0
⎠
far−near near−far
0 0 1 0
View- und Projectionmatrix können zu einer gemeinsamen Transformation konkateniert werden:
Transform = Projection · View (23)
Um einen dreidimensionalen Punkt p = ( x y z ) T
von Welt- in Bildschirmkoordinaten zu transformieren
wenden wir einfach diese Gesamttransformation auf den Punkt an:
⎛ ⎞
⎛ ⎞
x C
x
p C = ⎜y C
⎟
⎝ z C
⎠ = Transform · ⎜y
⎟
⎝z⎠ (24)
w C 1
Durch anschließende Homogenisierung erhalten wir den Punkt p D
⎛ ⎞ ⎛ ⎞
x D
p D = ⎝y D
⎠ = 1 x C
⎝y C
⎠ (25)
w
z C D z C
Dieser Punkt liegt nun in sogenannten normalisierten Gerätekoordinaten vor. Dabei handelt es sich um ein
Koordinatensystem in dem der Punkt (−1, 1) der linken oberen Ecke und (1, −1) der rechten unteren Ecke
des Ausgabebildes entspricht. Die z-Koordinate liegt für alle Punkte die sich zwischen der near und far
23

y
x
z
(−1, 1, 0)
y
z
x
(1, −1, 1)
Abbildung 24: Transformation des Viewspace in normalisierte Gerätekoordinaten.
Plane befinden im Intervall [0, 1] (0 entspricht einem Punkt genau auf der near- und 1 einem Punkt auf der
far Plane). Wie in Abbildung 24 veranschaulicht kann man sich diesen ganzen Vorgang geometrisch als
eine Abbildung der Sichtpyramide in einen Quader vorstellen. Durch eine einfache lineare Transformation
können diese Koordinaten nun in Screenspace-Koordinaten umgerechnet werden, wie der Rasterizer sie
erwartet. Der Screenspace soll sich von der linken oberen Ecke des linken oberen Pixels des Framebuffer
mit den Koordinaten (0, 0) bis zur rechten unteren Ecke des rechten unteren Pixels mit den Koordinaten
(w, h) erstrecken (wobei w wieder die Breite und h die Höhe des Framebuffer ist).
Triangle Rasterization (5 Punkte) Die in den Screenspace transformierten Dreiecke sollen schlussendlich
mit Hilfe eines Scanline-Algorithmus rasterisiert werden. Dabei wird jedes Dreieck wie in Abbildung
25 dargestellt zeilenweise abgetastet. In jeder Zeile (Scanline) wird der erste und letzte zum Dreieck gehörende
Pixel bestimmt und dieser Bereich dann mit der Dreiecksfarbe gefüllt.
Zunächst werden die Vertices dazu aufsteigend nach ihrer y-Koordinate geordnet sodass das Problem sich
auf die zwei in Abbildung 26 dargestellten Fälle reduziert. Dann werden die linke und rechte Dreieckskante
entsprechend dem DDA Algorithmus (in der Vorlesung behandelt, sie Folien) abgetastet um den Start
24

Abbildung 25: Scanline-Rasterisierung (Scan-Conversion) eines Dreiecks.
v 0
v 0
v 2
v 1
(a)
v 2
v 1
(b)
Abbildung 26: Die zwei möglichen Konfigurationen bei der Scanline-Rasterisierung.
sowie Endpunkt jeder Scanline zu bestimmen. Dazu werden die Steigungen der linken und rechten Kante
bestimmt und die Start und Endpunkte dann für jede Scanline inkrementell berechnet. Das Dreieck wird
effektiv in zwei Teilen rasterisiert: Zeilenweise erst von v 0 nach v 1 und dann von v 1 nach v 2 .
Wesentlich für die Funktion eines Rasterizers ist die sogenannte Fill-Convention die festlegt unter welchen
Bedingungen ein Pixel zum Dreieck gehört. Der Rasterizer in dieser Übung soll der in der Praxis üblichen
Top-Left Fill-Convention folgen. Dabei zählt ein Pixel dann als innerhalb eines Dreiecks wenn sein Mittelpunkt
innerhalb aller Dreieckskanten liegt. Liegt der Mittelpunkt eines Pixels genau auf einer Kante so
zählt er als innerhalb wenn es sich dabei um eine linke oder horizontale obere Kante des Dreiecks handelt
(Top oder Left). Ohne eine solche Fill-Convention würden beim Rendern von zusammenhängenden
Dreiecksnetzen störende Artefakte auftreten, da es zwischen angrenzenden Dreiecken zu Lücken oder zum
abwechselnden Übermalen von Pixeln kommen kann. Die Fill-Convention stellt sicher dass jeder Pixel
immer genau einem Dreieck zuzuordnen ist und solche Probleme nicht auftreten. Abbildung 27 illustriert
dies an einigen Beispielen.
25

Abbildung 27: Dreiecke rasterisiert mit Top-Left Fill-Convention.
Visibility (3 Punkte) Ohne Berücksichtigung anderer Dreiecke und deren Tiefe, werden Dreiecke einfach
in der Reihenfolge, in welcher der Rasterizer sie bearbeitet gezeichnet. Da sich Dreiecke im Raum in
der Regel natürlich gegenseitig verdecken oder gar durchdringen können ist dies für die Darstellung von
3D Szenen unzureichend. Um das Sichtbarkeitsproblem zu lösen bedienen wir uns eines Depth-Buffers
(Z-Buffer). Dabei handelt es sich um einen zusätzlichen Buffer in dem für jeden Pixel ein Tiefenwert gespeichert
wird. Bevor ein Pixel überschrieben wird, wird zuerst überprüft ob der Tiefenwert des neuen
Pixels kleiner (Pixel liegt näher am Betrachter) oder gleich dem momentan im Depth-Buffer befindlichen
Tiefenwert ist. Nur wenn dies der Fall ist wird der Pixel gezeichnet. So werden alle Dreiecke unabhängig
von ihrer Rasterisierungsreihenfolge immer korrekt dargestellt. Um diesen Algorithmus implementieren
zu können muss für jeden Pixel dessen Tiefenwert bekannt sein. Dieser wird berechnet indem nicht nur
die Position sondern – nach dem selben Prinzip (DDA Algorithmus) – auch die Tiefenwerte der Vertices
entlang der Kanten und dann von Beginn zum Ende jeder Scanline linear interpoliert werden.
5.2 Programmgerüst
Das zur Verfügung gestellte Programmgerüst enthält bereits die notwendige Infrastruktur (Konfigurationsdatei
einlesen, Ausgabebild speichern, etc.). Um die Übungsaufgabe zu lösen müssen nur noch die
jeweiligen Methoden der Klasse Rasterizer entsprechend implementiert werden:
• Rasterizer::SetCamera(): Hier werden die View- und Projectionmatrix berechnet.
• Rasterizer::TransformVertex(): Diese Methode transformiert einen Vertex vom Worldin
den Screenspace und liefert ein entsprechendes Objekt vom Typ ScreenVertex zurück.
• Rasterizer::RasterizeTriangle(): Implementiert das Rasterisieren eines Dreiecks.
26

5.3 Hinweise
Alle Methoden befinden sich in der Datei „Rasterizer.cpp“ und sind durch Kommentare (TODO)
gekennzeichnet. In jeder dieser Methoden befindet sich auch ein kurzes Codebeispiel das den Umgang
mit den Framework-Klassen demonstriert. Dieser Beispielcode ist durch Ihre eigene Implementierung zu
ersetzen.
Je nach Konfiguration werden entweder zwei oder drei Bilddateien erzeugt. Die Datei „testcase.png“
enthält das gerenderte Bild, „testcase.depth.png“ den Inhalt des Depth-Buffers. Eine vergrößerte
Version des Ausgabebildes ist in „testcase.upsample.png“ enthalten. Hier sind die Dreieckskanten
als Linien überlagert. Das Letzte Bild wird nur erzeugt wenn der Parameter upsample angegeben wurde.
Dies dient der praktischen Überprüfung der Fill-Convention. Das Generieren dieses Bildes kann unter
Umständen länger dauern. Verwenden Sie dieses Feature vorzugsweise für Testcases deren Ausgabebilder
eine geringe Auflösung haben.
Es empfiehlt sich die einzelnen Punkte der Aufgabestellung in der Reihenfolge in der sie hier beschrieben
wurden zu lösen. Der Beispielcode in Rasterizer::RasterizeTriangle() sorgt dafür dass die
jeweilige Testszene basierend auf den von ihnen transformierten Vertices automatisch als Drahtgittermodell
ausgegeben wird. So erhalten Sie von Anfang an (auch implementierte Rasterisierungsfunktion) visuelles
Feedback.
Entwickeln Sie eigene Testkonfigurationen um ihr Programm ausgiebig zu testen. Die beigelegten Testcases
dienen hier nur als Ausgangspunkt.
Literatur
[FA91] William T. Freeman and Edward H. Adelson. The design and use of steerable filters. IEEE
Transactions on Pattern Analysis and Machine Intelligence, 13:891–906, 1991.
[HB04] Donald Hearn and M. Pauline Baker. Computer Graphics with OpenGL. Prentice Hall, 3rd edition,
2004.
27