CG1-01-15.pdf

1
Computergrafik II
Prof. Dr.-Ing. habil. Wolfgang Oertel
Fakultät Informatik/Mathematik
HTW Dresden
11. Einführung Ei füh in i die di Computergrafik
C t fik 99. HHelligkeits- lli k it undd FFarbdarstellung bd t ll
2. OpenGL: Struktur und Programmierung 10. Rasterkonvertierung von Linien und Flächen
3. OpenGL: Ansicht und Transformation 11. Klippen und Glätten
4. OpenGL: p Kurven und Flächen
12. Sichtbarkeitsbestimmungg
5. OpenGL: Material und Beleuchtung 13. Geometrische Transformationen
6. OpenGL: Bitmaps, Bilder und Texturen 14. Geometrische Projektionen
7. OpenGL: Effekte, Puffer und Interaktion 15. Mathematische Grundlagen
88. OpenGL: Shading Language Language
Praktikum: OpenGL, C

2
Literatur
• Orlamünder Orlamünder, D.; D ; Mascolus, Mascolus W.: W : Computergrafik und und OpenGL. OpenGL Fachbuchverlag Fachbuchverlag, Leipzig, Leipzig 2004 2004
• Hill, F.: Computer Graphics Using OpenGL. Prentice Hall, Upper Saddle River, 1990
• Shriner, D.; Woo, M.; Neider, J.; Davis, T.: OpenGL Programming Guide. Addison-Wesley, Paris, 2006
• Shriner, D. (Ed.): OpenGL Reference Manual. Addison-Wesley, Munich, 2000
• Burggraf,L.: OpenGL: Der einfache Einstieg in die Schnittstellenprogr. Markt+Technik, München, 2003
• Aperti, M.: OpenGL: Das umfassende Praxis-Handbuch. Mitp, Heidelberg, 2010
• Wright, R.; Haemel, N.; et al.: OpenGL SuperBible. Pearson Education, Boston, 2011
• Shriner Shriner, D.; D ; Woo, Woo M.; M ; Neider, Neider J.; J ; et et al.: al : OpenGL OpenGL Programming Guide. Guide Pearson Pearson Education, Education Boston, Boston 2010 2010
• Rost, R.; et al.: OpenGL Shading Language. Pearson Education, Boston, 2010
• Foley, J.; van Dam, A.; Feiner, S.; Hughes, J.: Computer Graphics. Addison-Wesley, Bonn, 1990
• Encarnacao Encarnacao, J J.; ; Straßer Straßer, W.: W : Graphische Datenverarbeitung 1 und und 2. 2 Oldenbourg Oldenbourg, München, München 1996, 1996 1997 1997
• Bender, M.; Brill, M.: Computergrafik. Hanser, München, 2003
• Nischwitz, A.; Haberäcker, P.: Masterkurs Computergrafik und Bildverarbeitung. Vieweg, Wiesb., 2004
• Vince, J.: Mathematics for Computer Graphics. Springer, London, 2006
Internet: www.opengl.org, www.sgi.com/products/software/opengl
www.computer.org/cga, www.siggraph.org
Tag Tagung: ng: Si Siggraph, h Eurographics
E hi
Zeitschrift: IEEE Computer graphics and applications, ACM Transactions on graphics
Institution: SGI, FhG/IGD, ZGDV, INI-Graphics Net ,GI-ANIS
Die Lehrveranstaltung baut inhaltlich auf obiger Literatur auf.
Verwendung des Skriptes nur für den privaten Gebrauch!

3
1. Einführung g in die
Computergrafik
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziel:
Vermittlung
- nutzbarer Fertigkeiten, computergraphische Softwarekomponenten zu entwickeln
und computergraphische computergraphische Konzepte in in Anwendungssysteme einzubringen
- theoretisch fundierter praxis- und anwendungsorientierter Kenntnisse über
computergraphische Modelle, Verfahren und Systeme
Methodik:
• Wissensvermittlung über Vorlesung
• Demonstration und ÜÜbung
an anwendungsorientierten Beispielen
• Eigene problemorientierte Entwurfs- und Programmiertätigkeit
• Orientierung an allgemeiner Standardliteratur mit Verweis auf Spezialliteratur
• Nutzung von Standardsystemen Standardsystemen (OpenGL)
Schwerpunkt: Generative Computergrafik

4
Geschichte
Vorgeschichte: - Mathematik: Algebra, Geometrie, Numerik, Vektorrechnung
- Zeichen- und Maltechniken
- 350 v.u.Z., 980: Camera Obscura (Aristoteles, Alhazen)
- 1435 1435: ZZentralperspektive l k i (L (L. BB. Alb Alberti) i)
- 1510: Perspektivmaschine (L. da Vinci, A. Dürer)
- Foto, Film, Fernsehen, Kunst
TTriebkraft: i bk f - Hardwareentwicklung
- Einzelfertigung � Serienfertigung � Massenmarkt
1941: Computer als neue technische Basis
1950: Plotter, Kathodenstrahlröhre, Lichtgriffel
1960: Grafikkonzepte, Vektorgrafik
1970: CAD-Systeme in Industrie, firmenspezifisch, einzelne teure Systeme
1980 1980: Schnittstellen und allgemeine Standards
Rastergrafik, massenhafte kostengünstige Systeme
1990: Geräteunabhängige Systeme und Industriestandards
2000: Virtuelle Virtuelle Realität, Realität Realistische Realistische Darstellung, Darstellung Animation Animation
Gegenwart: Vielzahl von Entwicklungs- und Anwendungssystemen
Zukunft: - Grafik als integraler Bestandteil aller nutzerorientierten nutzerorientierten Softwaresysteme
Softwaresysteme
- realistische 3D-Grafik als tragendes Element aller Nutzerschnittstellen
- Liniengrafik � Flächengrafik � Volumengrafik

5
Grundbegriffe
Grafische Datenverarbeitung: Methoden und Techniken zur Konvertierung von Daten
zwischen Computer und grafischen Endgeräten
Teilgebiete:
Computergrafik: realisiert Verfahren zur Produktion und Manipulation von Bildern als
Repräsentanten rechnerinterner Darstellungen zur Visualisierung auf
grafischen Ausgabegeräten
Bildverarbeitung: transformiert natürliche von grafischen Eingabegeräten bereitgestellte
Bilder zu neuen Bildern und wertet sie nach ihren Inhalten und
Bedeutungen aus
Alternative Begriffe:
- computer graphics, image processing
- generative Computergrafik, Bildsynthese
- kkognitive iti Computergrafik, C t fik Bildanalyse Bild l
- Grafiktransformation, Bildbearbeitung
- Computeranimation, Videoverarbeitung

6
Systematisierung der Teilgebiete
Grafische Datenverarbeitung
Bildverarbeitung
GGrafik fi
Objekte
Grafiktransformation
zeitlicher Prozess
Raumstruktur
Bildanalyse Bildsynthese
Bild
Pixel
zeitlicher Prozess
Bildbearbeitung
Matrixstruktur
Computergrafik

7
Generative Computergrafik
Zielobjekt ist der Mensch mit seinen visuellen und manuellen Fähigkeiten:
Verarbeiten und - ebenen und räumlichen Darstellungen
Erzeugen g von - graustufigen g g und farblichen Darstellungen g
- statischen und bewegten Darstellungen
- attributierten Darstellungen
AAusgabekonzepte: b k t Vi Visualisieren, li i Animieren, A i i Schreiben S h ib
Eingabekonzepte: Deuten, Zeigen, Wählen, Benennen
Klassifikation:
Passives System: System erzeugt grafische Darstellungen und übergibt sie dem Nutzer
Aktives System: Nutzer erzeugt grafische Darstellungen und übergibt sie dem System
Interaktives Systeme: wechselseitiges Erzeugen und Verarbeiten von grafischen Darstellungen
Systemkonzept:
y p
Verarbeiten
Nutzer
Erzeugen
Erzeugen
Anwendungs- Grafiksystem
system
Verarbeiten

8
Systemarchitektur
iinteraktive k i generative i grafische fi h Systeme S
Einheitliches Modell (Grundkonfiguration, ( g , Kernsystem) y ) für grafische g Hardware-Software-Systeme y
Nutzer
Anwendungs- GrafikGrafik-
programme software fthhardware
d
Gerätedaten
Grafikdaten
Anwendungsdaten
Mensch
Anwendungsschnittstelle Anwendungsschnittstelle Geräteschnittstelle Nutzerschnittstelle
Auswahlkriterien:
…system
.
.
.
� Auflösung
� Farbe
� Größe
� Geschwindigkeit
Grafik…
.
.
.
� Verfahren
� Interaktion
� Sprache
� Elemente
Anwendungssystem
.
.
.
� Modelle
� Strukturen
� Algorithmen
� Sichten

9
Grafische Datenstrukturen
Anwendungsdaten: Daten zur Repräsentation von Objekten, Beziehungen, Prozessen und
Gesetzmäßigkeiten des Anwendungsbereiches einschließlich topologischer und
geometrischer Daten
Struktur: Frames, Hierarchien, Netze, Topologien, Geometrien
Eigenschaft: Komplexität, Konnektivität, Abstraktionsgrad
Operation: Modellieren, Simulieren, Überwachen, Berechnen, Bewerten
Grafikdaten: primitive und komplexe Objekte zur grafischen Repräsentation mit zugehörigen
Hierarchien, , Eigenschaften g und Operationen p
Struktur: Raster, Vektor; 2D, 3D; Punkt, Linie, Fläche, Volumen, Text
Eigenschaft: Position, Lage, Sichtbarkeit, Farbe, Identifizierbarkeit
OOperation: ti Erzeugen, E Löschen, Lö h Kopieren, K i Transformieren, T f i Modifizieren
M difi i
Gerätedaten: Einheiten zur Ansteuerung der elementaren Funktionen der Gerätetechnik zum
Zwecke der Eingabe und Ausgabe
Struktur: - Vektor mit Richtung und Länge
- Rasterpunkt mit Koordinaten Koordinaten und Farbwert;
- höhere grafische Primitive
Tendenz: Annäherung zwischen Geräte- und Grafikdaten

10
Grafische Programmiersprachen
Grafiksprache: Sprache, die die Bearbeitung, Verarbeitung, Eingabe und Ausgabe
grafischer Daten ermöglicht
Eb Ebene:
RRealisierung: li i
- eigenständige Sprache
- Unterprogrammpaket (Bibliothek)
- SSpracherweiterung h i über b CCompiler il
- Spracherweiterung über Präprozessor
- erweiterbare Sprache
- Maschinensprache
- maschinenorientierte Programmiersprache
- problemorientierte bl i i Programmiersprache i h
- benutzerorientierte Programmiersprache
- Kommandosprache
Software:
- Standards: PHIGS PHIGS, GKS GKS, VRML VRML, X3D
- Industriestandards: OpenGL, DirectX, Direct3D, Java3D
- Systeme: AutoCAD, 3D Studio MAX, IDL
Blender, Cinema 4D, Maya
Autodesk Inventor, Solid Works

11
Grafik-Standards
Grafik-Standard: Festlegung elementarer grafischer Strukturen und zugehöriger Operationen,
dadurch Definition der Schnittstelle zwischen Anwendungssystem und Grafik-System
mit den Zielen Wiederverwendbarkeit, Portabilität und Effizienz
aus: Encarnacao u.a.: Graphische Datenverarbeitung 1, Oldenbourg, 1996

12
Historische Entwicklung
Zeitskala:
Echte Standards: Industrie-Standards Jahr:
-------------------------------------------------------------
GKS 1985
GKS-3D 1987
X11 1987
HOOPS 1987
PHIGS 1988
PEX 1989
OpenInventor 1990
PHIGS+ 1991
OpenGL 1992
DirectX 1995
Mesa3D 1995
Direct3D 1996
VRML 1997
Java3D 1998
OOpenSceneGraph S G h 2001
SVG 2001
X3D 2004
OpenGLSL 2004
CUDA 2007
OpenCL 2008

13
Grafische Standards, Normen und Systeme
- GKS: Graphical Kernel System, ISO7942, 1985
- GKS-3D: Graphical Kernel System for Three Dimensions, ISO8805, 1988
- PHIGS: Programmers Hierarchical Interactive Graphics System, ISO9592-1, 1989
- PHIGS PLUS: Erweitertes PHIGS, ISO9592-1, 1992
- X: X-Windows-System, Unix-Arbeitsplätze, 2D, 1986
- PEX: PHIGS Extensions for X-Windows, 3D, 1989
- OpenGL: SGI Graphic Graphic Library, Library 1993 1993
- HOOPS: Hierarchical Object-Oriented Picture System, ITHACA Software, 1991
- GKS-C: Sprachanbindung an Programmiersprache C (analog für Fortran, Pascal, …)
- CGI: Common Graphics Interface, Virtuelle Geräteschnittstelle, ISO9636, 1991
- CGM: Common Graphics Metafile, Bilddaten, ISO8632, 1987
- IGES: Initial Graphics Exchange Specification, Technische Zeichnungen
- VDA-FS: Flächenschnittstelle (D)
- SAT SAT, SET: SET: 3D CAD-Formate CAD Formate (USA (USA, FR) FR)
- DWG, DXF: AutoCAD-Formate
- STEP: Standard for the Exchange of Product Model Data, ISO10303, 1993
- DIRECT3D: 3D-Graphics API for real time
- Java 3D: Klassenbibliothek zur Modellierung und Manipulation von 3D Objekten
- VRML: Virtual Reality Modelling Language, ISO14772-1, 1997
- X3D: Extensible 3D, ISO19775, ISO19776, ISO19777, 2004
- verschiedene Schnittstellenformate Schnittstellenformate im Geometrie-, Geometrie- Bild- und Ausgabebereich
Ausgabebereich
- OPENGL ES, M3G: Mobile Grafik-Standards, 2001, 2002
- SVG: Scalable Vector Graphics

14
Grafische Hardware
Hardware:
- Computer, Speicher, Peripherie, Peripherie, Netz
- Grafikkarte (NVIDIA, ATI)
- Drucker, Plotter
- Display, Stereo-Display, Stereobrille,
- HHead-Mounted-Display, d M d Di l PProjektor, j k CCave
- Tastatur, Maus, Lichtstift, Zeichentablett
- Spaceball, Datenhandschuh,

15
Anwendungsgebiete
Bereiche: - Maschinenbau
- Architektur und Bauwesen
- Geoinformation, Kartografie
- Gebrauchs- und Geschäftsgrafik
- Medizin
- Modellierung und Simulation
- PProzessüberwachung üb h
- Unterhaltung und Spiele
- Konstruktion, Entwurf und Design
- wissenschaftlich-technische w sse sc a c ec sc e Visualisierung
V sua s e u g
- Kunst
- Mensch-Maschine-Kommunikation
- Computeranimation, Virtuelle Realität
Kategorien: - technisch
- wissenschaftlich
- institutionell
- wirtschaftlich
- privat

16
2. OpenGL: Struktur und
Programmierung
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Kennenlernen grundlegender Strukturen von OpenGL-Programmen
• Einführung elementarer Zeichenfunktionen
Abschnitte:
Grundlegendes und
einfache Zeichenfunktionen
- Überblick
- Grafik-Bibliotheken
- Realisierung
- Sprachsyntax
- Programmierung
- Zeichnen im Raum
- Punkte, Linien
- Dreiecke Dreiecke, Rechtecke, Rechtecke Polygone Polygone
- Darstellungsattribute
- Funktionsreferenz

17
Überblick
OpenGL Eigenschaften:
- Software Software Interface Interface zu zu grafischer grafischer Hardware Hardware
- portables und effizientes 3D-Grafik- und -Modellierungswerkzeug
- keine Programmiersprache, sondern eine Laufzeitbibliothek
- Industriestandard, 1992 entwickelt aus IRIS GL von Silicon Graphics
- kontrolliert durch Architectural Review Port (ARB)
- Führung durch Industriekonsortium Khronos Group (ATI, NVIDIA, Intel, SGI, Sun)
- Versionen: 1: 1992, 2: 2004, 3: 2008, 4: 2010
- verfügbar für alle bedeutenden bedeutenden Hardware- Hardware-, Betriebs- und Programmiersysteme
Programmiersysteme
OpenGL Arbeitsweise:
• Prozedurales (kein deskriptives) grafisches API
• ca. 220 Befehle (GL + GLU)
• ca. 240 Zustandsvariablen
• arbeitet als Zustandsmaschine (grafische Ausgabe bestimmt sich aus Zustand und Eingabe)
• schrittweise Abarbeitung in einer Pipeline (von Befehlsaufruf bis zur Bildschirmanzeige)
Portabler und offener Industriestandard

18
Grafik-Bibliotheken
GL GL: OOpenGL GL BBasis i Bibliothek Bibli th k (gl.h, ( l h opengl32.dll) l32 dll)
- sämtliche Basisfunktionen und Zustandsvariablen in C
GLU: GLU: OpenGL Utility Library (glu.h, (glu h glu32.dll) glu32 dll)
- auf Basisfunktionen aufsetzende komplexe Funktionen in C
- z.B. Perspektive, Projektion, Polygonzerlegung, Oberflächengestaltung
GLUT GLUT: OOpenGL GL UUtility ili TToolkit lki ( (glut.h, l h glut32.dll) l 32 dll)
- systemunabhängige Funktionen zur Window-Verarbeitung
- z.B. Window-Management, Ereignisbehandlung, 3D-Objekt-Zeichnung
Arbeit be t mit t Display sp ay Callbacks, Ca bac s, Programmen og a e und u d Prozessen o esse
GLX, WGL: spezifische Erweiterungen für Window Systeme:
X Window System, Microsoft Windows
Open Scene Graph, Open Inventor: objektorientierter Werkzeugkasten
- vorgefertigte Objekte und Methoden in C++
- zur Erzeugung Erzeugung interaktiver interaktiver 3D-Grafik-Anwendungen
3D Grafik Anwendungen
Extensions: (noch) nicht standardisierte Erweiterungen
- GL_ARB_..., GL_EXT_..., GL_ATI_..., GL_NV_..., . . .
GLEW, Glee: Verwaltung von Erweiterungen und Kernfunktionen (Testen, Laden, Einbinden)
- plattformübergreifende Unterstützung

19
Versionen
Bibliothek/Version: Jahr: neuer Inhalt:
-----------------------------------------------------------------------------------------------------------------------
OpenGL 1.0 1992 erste Veröffentlichung
1.1 1997 Vertex Arrays, Texture Objects, Polygon Offset
1.2 1998 3D-Texturen, Pixelformate, LOD
1.3 2001 komprimierte Texturen, Cube-Maps, Multitexturing
11.4 4 2002 Tiefentexturen Tiefentexturen, Mip-Maps Mip Maps, Nebelkoordinaten
1.5 2003 Pufferobjekte, Occlusion Queries
2.0 2004 GLSL 1.1, Multiple Render Targets, große Texturen
2.1 2006 Pixel Buffer Objects, GLSL 1.2, sRGB-Texturen
3.0 2008 GLSL 1.3, Entfernen f von Altlasten, l l keine k i Abwärtskompatibilität
b k ibili
3.1 2009 entfernte Altlasten, über compatibility extension verfügbar,
GLSL 1.4, Uniform Buffer Objects, Primitive Restart, Instancing
3.2 2009 2009 höhere Geschwindigkeit, Geschwindigkeit, verbesserte Darstellungsqualität,
vereinfachte Portierung von Direct3D, GLSL 1.50
3.3 2010 Einbindung von OpenCL, Geometrie-Shader, GLSL 3.3
4.0 2010 Tessellations-Shader, GLSL 4.0
44.1 1 2010 2010 iinäre ä Shader, Sh d höhere höh PPräzision ä i i dder Sh Shader, d GLSL 44.1 1
4.2 2011 atomic counters, image store and load, GLSL 4.2
OpenGLSL 1.x 2004 Programmierbare Vertex- und Fragment-Shader
33.x 2010 PProgrammierbare i b Geometrie-Shader
G i Sh d
4.x 2010 Programmierbare Tesselations-Shader

20
Realisierung
Software- und Hardware-Implementation:
AApplication li ti Program P
Graphics Device Interface Software Rasterizer
OpenGL
Display /Window System Hardware Driver
Rendering g Pipeline: p
Vertex Data Evaluators Vertex Operations Primitive Assembly
Framebuffer
Fragment
Operations
Display List Rasterization
Pixel Data Pixel Operations Texture Assembly

21
Sprachsyntax
Funktionsnamen: glColor3f (x,y,z)
mit Bibliothek, Funktion, Argumentanzahl, Argumenttyp
Variablenamen: GL_COLOR_BUFFER_BIT
mit Bibliothek, Variable
Datentypen: yp
OpenGL-Typ: Suffix: C-Typ: Datentyp:
------------------------------------------------------------------------------------------------------------------------
GLbyte b signed char 8-bit integer
GL GLshort h t s short 16 16-bit bit integer integer
Glint, GLsizei i int, long 32-bit integer
GLfloat, GLclampf f float 32-bit floating-point
GLdouble, GLclampd p d double 64-bit floating-point g p
GLubyte, GLboolean ub unsigned char 8-bit unsigned integer
GLushort us unsigned short 16-bit unsigned integer
GLuint, Glenum, ui unsigned int, unsigned long 32-bit unsigned integer
GLbitfield
Arrays und Pointer: GLshort shorts[10]; glColor3iv(cv); glVertex3fv(vv);
GLdouble *doubles;
Weitere Kürzel: gluPerspective(); GLU_FILL
glutSetColor(); GLUT_RGB

22
Programmierung
Rahmenprogramm:
static void myReshape
(int w,int h)
{glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,1.0,0.0,1.0);}
2 0 0 0 0 0 0
#include
# #include /
#include
static void myinit
(void) i
{glClearColor (0.0,0.0,0.0,1.0);}
void main(int argc,char** argv)
{glutInitDisplayMode(GLUT_SINGLE|
GLUT_RGB|GLUT_ALPHA|GLUT_DEPTH);
| | )
glutInitWindowPosition(0,0);
glutInitWindowSize(500,500);
glutInit(&argc,argv);
glutCreateWindow(argv[0]);
l C i d ( [0])
myinit();
glutReshapeFunc(myReshape);
glutDisplayFunc(myDisplay);
glutMainLoop();}
l tM i L () }
static void myDisplay
( (void) id)
{glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,1,1);
lC l 3f(1 1 1)
glBegin(GL_LINE_LOOP);
glVertex2f(0.25,0.25);
glVertex2f(0.75,0.25);
glVertex2f(0.75,0.75);
lV t 2f(0 75 0 75)
glVertex2f(0.25,0.75);
glEnd();
glFlush();}

23
Funktionsreferenz
GLUT:
glutAddMenuEntry - Erzeugen eines Menü-Eintrages
glutAddSubMenu l tAddS bM - EErzeugen eines i Unter-Menüs
U t M ü
glutAttachMenu - Bindung eines Menüs an eine Maustaste
glutCreateMenu - Erzeugen eines Popup-Menüs
glutCreateWindow g - Erzeugen g eines OpenGL-fähigen p g Fensters
glutDisplayFunc - Setzen der Anzeige Callback Funktion
glutInitDisplayMode - Initialisieren des Anzeigemodus
glutIdleFunc - Setzen der Lehrlauffunktion
glutInit l tI it - IInitialisieren iti li i von GLUT GLUT mit it Argumentübergabe
A tüb b
glutInitWindowPosition - Festlegen der Fensterposition
glutInitWindowSize - Festlegen der Fenstergröße
glutKeyboardFunc g y
- Setzen der Tastatur Callback Funktion
glutMainLoop - Starten der Hauptverarbeitungsschleife
glutMotionFunc - Setzen der Mausbewegung Callback Funktion
glutMouseFunc - Setzen der Mausbutton Callback Funktion
glutReshapeFunc l tR h F - Setzen der der Fensteränderung Callback Funktion
glutPostRedisplay - Aktualisieren des Fensters
glutSpecialFunc - Setzen der Tastatur Callback Funktion für Nicht-ASCII-Zeichen
glutSwapBuffers g p - Übertragen g vom unsichtbaren zum sichtbaren Puffer
glutTimerFunc - Setzen einer Zeit Callback Funktion

24
GLUT:
glutSolid*,glutWire* - Zeichnen von 3D-Objekten als Festkörper oder Drahtgitter
*: Cone,Cube,Sphere,Torus,Teapot,Dodeca-,Icosa-,Octa-,Tetrahedron
glutBitmapCharacter g p - Ausgabe g eines Zeichens an Rasterposition p in Framepuffer p
glutStrokeCharacter - Ausgabe eines Zeichens an Position in Modellbereich
GL:
glMatrixMode - Festlegen der des Matrixmodus
glLoadIdentity - Laden der Einheitsmatrix
glClearColor - Angabe der Hintergrundfarbe
Hintergrundfarbe
glColor - Angabe der Zeichenfarbe
glClear - Löschen des Puffers
glBegin - Beginn grafischer Primitive
glVertex - AAngabe b eines i EEckpunktes k k
glEnd - Ende grafischer Primitive
glFlush - Forcierung der Ausgabe
glViewport - Angabe des Bildschirmbereiches
Bildschirmbereiches
glOrtho - Angabe des Modellbereiches

25
Zeichnen im Raum
Prinzipien: - Aufbau komplexer Objekte aus elementaren Objekten (Punkt, Linie, Polygon, …)
- Arbeit im 3D Modellbereich
- Automatische Transformation in Bildschirmbereich
- RRechte-Hand-Regel h H d R l für fü KKoordinatensystem di undd Rotation R i
Kartesischer Modellbereich (View Volume):
y
glOrtho(left,right,bottom,top,near,far);
3D Eckpunkt (Scheitelpunkt, Vertex):
x
glVertex2(x,y);
glVertex3(x,y,z);
glVertex4(x,y,z,w);
Blickrichtung li k i h
Definition von grafischen Primitiven:
z
glBegin(mode);
glVertex3f(x1,y1,z1);
glVertex3f(x1,y1,z1);
glVertex3f(x2,y2,z2);
glEnd();
Parameter mode steuert Interpretation der Punkte.
nur bestimmte Kommandos zwischen glBegin und glEnd zugelassen

26
Punkte, Linien
Punkte:
glBegin(GL_POINTS);
0 1
2 3
Linien:
glBegin(GL_LINES);
glBegin(GL_LINE_STRIP);
glBegin(GL_LINE_LOOP);
0 1
Beispiele:
2 3
0 1
2 3
glBegin(GL_POINTS);
glVertex3f(0 glVertex3f(0.0,2.0,1.0);
0 2 0 1 0);
glVertex3f(3.0,2.0,1.0);
glVertex3f(1.0,0.0,1.0);
glVertex3f(4.0,0.0,1.0);
glEnd();
0 1
2 3
glBegin(GL_LINES);
for(i=-1.57;i

27
Dreiecke, Rechtecke, Polygone
5
2
1
4 0
3
Dreiecke:
glBegin(GL_TRIANGLES);
glBegin(GL_TRIANGLE_STRIP);
glBegin(GL glBegin(GL_TRIANGLE_FAN);
TRIANGLE FAN);
4
0
5
3
2
Vierecke:
glBegin(GL_QUADS);
glBegin(GL glBegin(GL_QUAD_STRIP);
QUAD STRIP);
1
3
4
2
5
Polygone:
glBegin(GL_POLYGON);
1
0
Zeichenregeln: planar, konvex, nicht schneidend
6
7
3 2
5
0 1 4
6
7
0 2
1 3 4
5
4
3
5
6
2
0
7
1
Beispiele:
glBegin(GL_TRIANGLES);
glVertex2f(0.0,0.0);
glVertex2f(5.0,0.0);
glVertex2f(5.0,0.0);
glVertex2f(2.0,2.0);
glVertex2f(-5.0,0.0);
glVertex2f(-2.0,0.0);
glVertex2f(-7.0,5.0);
glEnd();
Angaben in Modellkoordinaten

28
Darstellungsattribute
Punktgröße: g
glPointSize(size);
Linienbreite:
glLineWidth(width);
g
Linienmuster:
glLineStipple(factor,pattern); (16-Bit-Maske)
PPolygondarstellung: l d t ll
glPolygonMode(face,mode); (GL_FRONT,GL_BACK,
GL_FRONT_AND_BACK;GL_POINT,GL_LINE,GL_FILL)
PPolygonmuster: l t
glPolygonStipple(pBitmap); (32x32-Bit-Maske)
Farbe:
glColor(red glColor(red,green,blue,alpha);
green blue alpha);
glIndex(index);
Setzen von Zustandsvariablen:
glEnable(cap), g p gglDisable(cap) p
cap: GL_LINE_STIPPLE, GL_POLYGON_STIPPLE, GL_POINT_SMOOTH, ...
Erlaubte Kommandos zwischen glBegin und glEnd:
glVertex,glColor,glIndex,glNormal,glTexCoord,glEdgeFlag,
g ,g ,g ,g ,g ,g g g,
glMaterial,glArrayElement,glEvalCoord,glEvalPoint,
glCallList,glCallLists
Angaben in Bildschirmkoordinaten

29
Farbe als Attribut
Wertebereich:
Suffix Minimalwert Abbildung Maximalwert Abbildung
--------------------------------------------------------------------------------------------------------ff,
d 0.0 0.0 1.0 1.0
b -128 -1.0 127 1.0
s -32768 -1.0 32767 1.0
i -2147483648 2147483648 -1.0 1.0 2147483647 1.0
ub 0 0.0 255 1.0
us 0 0.0 65535 1.0
ui 0 0.0 4294967295 1.0
Darstellungsmodus:
Übernahme der aktuellen Zeichenfarbe des Eckpunktes p bei nicht eingeschalteter g Beleuchtung g
- geglättet: interpolierte Färbung eines Primitives glShadeModel(GL_SMOOTH);
- Punkt: konstante Farbe
- Linie: Interpolation der Farben der Eckpunkte
- Fläche: Interpolation der der Farben der der Eckpunkte Eckpunkte
- flach: einheitliche Färbung eines Primitives glShadeModel(GL_FLAT);
- Punkt: konstante Farbe
- Linie: Farbe des jeweils j letzten Eckpunktes p
- Fläche: bei einzelnem Polygon Farbe des ersten Eckpunktes,
sonst Farbe des jeweils letzten Eckpunktes

31
Funktionsreferenz
glBegin - Beginn der Gruppe von Eckpunkten für ein grafisches Primitiv
glEnd - Ende der Gruppe von Eckpunkten für ein grafisches Primitiv
Mode: Mode: GL GL_POINTS, POINTS GL_LINES,GL_LINE_STRIP,GL_LINE_LOOP
GL LINES GL LINE STRIP GL LINE LOOP
GL_TRIANGLES,GL_TRIANGLE_STRIP,GL_TRIANGLE_FAN
GL_QUADS,GL_QUAD_STRIP, GL_POLYGON
glCullFace - Nichtzeichnen der der Vorder Vorder- oder Rückseite des des Polygons
glColor - Setzen der Zeichenfarbe über RGBA
glDisable - Rücknahme einer Fähigkeit
glEdgeFlag - Darstellung von Grenz- oder inneren Flächen
glEnable - Erlauben einer Fähigkeit
glFrontFace - Festlegen der Polygonvorderseite
glGetPolygonStipple - Liefern des aktuellen Polygonmusters
glIndex - Setzen der der Zeichenfarbe über über Index Index
glLineStipple - Setzen des Musters für das Linienzeichnen
glLineWidth - Setzen der Linienbreite
glPointParameter - Setzen von Texturkoordinaten für Point Sprites
glPointSize - Setzen der Punktgröße
glPolygonMode - Setzen des Darstellungs-Modus für das Polygonzeichnen
glPolygonStipple - Setzen des Musters für das Polygonzeichnen
glShadeModel - Festlegen der der Art der der Färbung Färbung von von Primitiven
glVertex - Angabe der Koordinaten eines Eckpunktes

32
3. OpenGL: p Ansicht und
Transformation
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Strukturen und Operationen für das Arbeiten im Raum
• Geometrie des 3D- und 2D-Raumes
• Grundlegende komplexe komplexe Datenstrukturen und und deren Operationen
Abschnitte:
- Motivation
- Transformationen
- Modelle
- Projektionen
- Viewports
- Matrizen
- Displaylisten
- Vertex Arrays Arbeit mit grafischen Daten im Raum

33
Motivation
Aufgabe: - geometrische Beschreibung der räumlichen Welt
- BBetrachtung t ht der d Welt W lt vom Standpunkt St d kt eines i Betrachters B t ht
- Festlegung eines sichtbaren Ausschnittes der Welt
- Überführung des Ausschnittes in ein Bild
- Formatierung g des Bildes zur Ausgabe g auf ein Medium
� Pipeline durchzuführender Transformationen
PProblem: bl - unterschiedliche t hi dli h Größen G öß der d einzelnen i l Bereiche B i h
- unterschiedliche Dimensionalität der Bereiche
- unterschiedliche Darstellung der Objekte
Start: - Menge von Scheitelpunkten der räumlichen Welt
Zi Ziel: l - MMenge von Pi Pixelwerten l t des d Ausgabemediums
A b di

34
Transformationen
Kameraanalogie:
Modell Ansicht Clip-Bereich Viewport Fenster
Transformationspipeline:
Modellansichts- Projektions- j
Perspektivische p
Viewport- p
matrix
matrix
Teilung
Transformation
Objekt- Augpunkt- Clip- Normalisierte Fenster-
Koordinaten
koordinaten koordinaten Gerätekoordinaten Koordinaten
(x,y,z)
(x,y,z)

35
Verwendung von Vektoren und Matrizen
Prinzip: - Open GL arbeitet extern mit 2D- oder 3D-Datenstrukturen bzw. -Operationen
- intern werden generell homogene Koordinaten verwendet
- dadurch alle Operationen Operationen über Multiplikationen ausführbar ausführbar
� - Operationen können mit 2D- oder 3D-Parametern aufgerufen werden
- Matrizen müssen explizit als 4D-Datenstrukturen angegeben werden
Vektoren: v= (x,y,z,w) T Operationen: v' = M v
Matrizen: M = m01 m05 m09 m13 m02 m06 m10 m14 m03 m07 m11 m15 m m04 m m08 m m12 m m16 Umwandlung: v= (x,y,z) T � v= (x,y,z,1) T
v= (x,y) T � v= (x,y,0,1) T
( ,y) ( ,y, , )
Operationen: alle geometrischen Operationen (Transformationen und Projektionen)
werden in homogenen Koordinaten über die Multiplikation von
MMatrizen t i undd Vektoren V kt ausgeführt
füh t

36
Modell- und Ansichts-Transformationen
Prinzip: - Modell- und Ansichts-Transformationen in einer Matrix festgelegt: GL_MODELVIEW
- schließt die Bewegung von Objekten und Kamera ein
- Sicht: festes Weltkoordinatensystem (WKS) mit bewegten Objekten oder
- Alt Alternative ti Sicht: Si ht Bewegung B des d Ansichtskoordinatensystems A i ht k di t t (AKS) mit it festen f t Objekten Obj kt
Modelltransformation: Position und Orientierung von Objekten im Weltkoordinatensystem WKS
glTranslate(x,y,z) - Verschiebung von Objekten um einen Vektor
glRotate(angle,x,y,z) - Drehung von Objekten mit einem Winkel um einen Vektor
glScale(x,y,z) - Skalieren von Objekten um Faktoren entlang der Achsen
Ansichtstransformation: Position und Orientierung des Ansichtspunktes im WKS
gluLookAt(eyex gluLookAt(eyex,eyey,eyez, eyey eyez - Festlegen des des Ansichtsstandpunktes,
Ansichtsstandpunktes
centerx,centery,centerz, des Ansichtszielpunktes und
upx,upy,upz) der Ansichtsobenausrichtung
(0.0,0.0,0.0, 0.0,0.0,-1.0, 0.0,1.0,0.0) - Initialwerte
(Ausführung in umgekehrter Reihenfolge)
Beispiel: glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(10 glTranslatef(10.0,0.0,0.0);
0 0 0 0 0);
glRotatef(-30.0,0.0,0.0,1.0);
glScalef(2.0,0.5,2.0);

37
Projektions-Transformationen
Projektions-Transformation: Festlegung des 2D- oder 3D-Bereiches im Ansichtskoordinatensystem
AKS
Prinzip: Prinzip: - Projektions-Transformationen Projektions Transformationen in einer Matrix Matrix definiert: GL GL_PROJECTION
PROJECTION
- mit Festlegung eines Projektionsverfahrens
- mit Festlegung des betrachteten räumlichen Bereiches
gluOrtho2D(left,right,bottom,top) - orthogonale Projektion 2D 2D
glOrtho(left,right,bottom,top,near,far) - orthogonale Projektion 3D
glFrustum(left,right,bottom,top,near,far) - perspektivische Projektion 3D
gluPerspective(fovy,aspect,near,far) - perspektivische Projektion 3D
right
top
left
bottom
near
top
right
top
right
left
left
bottom
bottom
far
near
far
fovy
w
h
near
aspect=w/h
Beispiel:
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);
far

38
Viewport-Transformationen
Viewport-Transformation: Festlegung des 2D Darstellungsbereiches im Fensterkoordinatensystem
FKS
Prinzip: - Ausgangspunkt sind normierte Projektionskoordinaten
- Viewport-Transformationen erzeugen geräte- und fensterunabhängige Koordinaten
- es entsteht ein 2D Bild mit x- und y-Pixelkoordinaten
- zz-Koordinaten Koordinaten im Bereich zwischen zwischen 0.0 0 0 und und 1.0 1 0 im Tiefenpuffer Tiefenpuffer verfügbar verfügbar
- Position und Größe in Pixelkoordinaten
- Ergebnis wird an Fenstersystem weitergegeben
- Größenverhältnis ist dem Clip-Bereich p anzupassen p
- Größe ist dem Fenster anzupassen
- Defaultwerte: gesamter Fensterbereich
glViewport(x,y,width,height) - Transformation in rechteckigen Bereich eines Fensters
glDepthRange(near,far) - Festlegen des Bereiches für die z-Koordinaten
y
Beispiel:
gluPerspective(30,2.0,20,50);
glViewport(0,0,400,200);
glViewport(400,200,100,100); x

39
Manipulation und Verwaltung von Matrizen
Matrizen-Manipulation: Operationen zur direkten Beeinflussung der Transformationsmatrizen
Prinzip: Prinzip: - Definition Definition, Änderung Änderung und und Verwendung von Matrizen
- 4 x 4 Elemente spaltenweise von links nach rechts und von oben nach unten angeben
Operationen:
glLoadIdentity() lL dId tit () - EErsetzen t der d aktuellen kt ll Matrix M t i durch d h die di Einheitsmatrix
Ei h it t i
glLoadMatrix(m) - Ersetzen der aktuellen Matrix durch eine spezifizierte Matrix
glMultMatrix(m) - Multiplikation der aktuellen Matrix mit einer spezifizierten Matrix
Matrizen-Stapel: Verwaltung von Matrizen in einem Stapel zur Speicherung von Zuständen bei
hierarchischen Programmstrukturen
Prinzip: - Es existieren 3 Stapel:
Modellierungs-, Projektions- und Textur-Matrizenstapel
- Stapelhöhe: Modellierung: Modellierung: >=32, 32, Projektion: >=2, 2, Textur: >=22
Operationen:
glMatrixMode(mode) - Festlegung des aktuellen Matrizen-Stapels
(GL ( _ MODELVIEW, , GL_ PROJECTION, , GL_ TEXTURE) )
glPushMatrix() - Ablegen der aktuellen Matrix auf den Matrizen-Stapel
glPopMatrix() - Entnehmen der obersten Matrix des Matrizen-Stapels
als aktuelle Matrix

40
Anmerkungen:
- Verwendung g unterschiedlicher Koordinatensysteme y und Matrizen für
- Modell- und Ansichtspunkt-Transformation � WKS, Modellmatix
- Projektions-Transformation � AKS, Projektionsmatrix
- Viewport-Transformation � FKS, ---
- Typische Typische Aufrufstellen von von
- Modell- und Ansichtspunkt-Transformation � display()
- Projektions-Transformation � reshape()
- Viewport-Transformation p � reshape() p ()
- Reihenfolge von Operationen ist wesentlich.
- Verkettung mehrerer Transformationen in einer Matrix
- Sequenz von Transformationen bedeutet
inverse Sequenz der Matrizenoperationen
Matrizenoperationen
Fragen bei leerem Bildschirm:
- Farben von Objekten und Hintergrund?
- Position und Größe der Objekte?
- Position und Ausrichtung des Ansichtspunktes?
- Objekte innerhalb des Sichtvolumens?
- Reihenfolge der der Transformationsoperationen?
Transformationsoperationen?
- Position und Größe des Viewports?

41
Funktionsreferenz
glClipPlane - Ebene zur weiteren Beschränkung des Modellbereiches
glGetClipPlane - Liefert Koeffizienten einer Beschränkungsebene
glDepthRange - Kodierungsbereich für z-Koordinaten bei Viewport-Transformation
glFrustum glFrustum - Perspektivischer Projektionsbereich mit mit Clip Clip-Ebenen Ebenen
glLoadIdentity - Initialisierung der aktuellen Matrix
glLoadMatrix - Setzen der aktuellen Matrix
glMatrixMode - Auswahl der aktuellen Matrix (des ( aktuellen Matrizen-Stapels) p )
glMultMatrix - Multiplikationder aktuellen Matrix mit einer Matrix
glOrtho - Orthogonaler Projektionsbereich
glPopMatrix - Entfernen der obersten Matrix vom Matrizen-Stapel
glPushMatrix - Ablegen der aktuellen aktuellen Matrix auf auf den den Matrizen-Stapel
Matrizen Stapel
glRotate - Rotation
glScale - Skalierung
glTranslate - Translation
glViewport - Viewport-Transformation
gluLookAt - Ansichtspunkt und -ziel
gluOrtho2D - Zweidimensionaler orthogonaler orthogonaler Projektionsbereich
gluPerspective - Perspektivischer Projektionsbereich mit Winkel und Verhältnis
gluPickMatrix - Zeichenbeschränkung auf dem Bildschirm
gluProject - Abbildung von Objekt- in Fensterkoordinaten
gluUnProject - Abbildung von Fenster- in Objektkoordinaten

43
Displaylisten
Displayliste: Zusammenfassung mehrerer OpenGL-Operationen zur späteren mehrfachen Ausführung
Prinzip: - Displaylisten werden durch eine Nummer identifiziert
- Aufbau hierarchischer Listen über Listenaufruf in Listendefinition
- automatisches Generieren von freien Listennummern möglich
Operationen: p
glNewList(list,mode) - Definition einer neuen Liste mit einer ganzen Zahl größer 0 und
einem Modus (GL_COMPILE, GL_COMPILE_AND_EXECUTE)
glEndList() - Ende der Listendefinition
glCallList(list) - Aufruf einer definierten Liste
glCallLists(n,type,*lists) - Ausführen mehrerer Listen
glGenLists(range) - Bereitstellung von mehreren Listennummern
glDeleteLists(list glDeleteLists(list,range) range) - Löschen mehrerer Listen Listen
nicht in Displaylisten erlaubte Operationen: glColorPointer, glDeleteLists, glFinish, glDisableClientState,
glEdgeFlagPointer, glEnableClientState, glFeedbackBuffer, glFlush, glGenLists, glGet*, glIndexPointer,
glInterleavedArrays, lI t l dA glIsEnabled, lI E bl d glIsList, lI Li t glNormalPointer, lN lP i t glPixelStore, lPi lSt glReadPixels, lR dPi l glRenderMode,
lR d M d
glSelectBuffer, glTexCoordPointer, glVertexPointer
Beispiel:
glNewList(1,GL_COMPILE);
i
glBegin(GL_POINTS); glVertex2f(0.2,0.2); glEnd();
glEndList(); glCallList(1);

44
Vertex Arrays
Vertex Array: effiziente Verwaltung von Vertex-Daten in mehrdimensionalen Feldern
Prinzip: Prinzip: - 1. Möglichkeit: Organisation von von Parameterdaten unabhängig unabhängig von von OpenGL OpenGL
und Nutzung dieser in OpenGL-Operationen
- 2. Möglichkeit: Nutzung spezieller OpenGL-Operationen
Operationen:
Operationen:
glEnableClientState(array) - Zulassen eines Arraytyps (GL_VERTEX_ARRAY;
für VERTEX auch COLOR, INDEX, NORMAL, TEXTURE_COORD, EDGE_FLAG)
glDisableClientState(array) - Nichtzulassen eines Arraytyps
glVertexPointer(size,type,stride,pointer) l i i i i - DDefinition fi i i eines i Arrays A mit i Punkten P k
glArrayElement(index) - Verwendung eines einzelnen Arrayelements
glDrawArrays(mode,first,count) - Sequenz von Primitiven mit Arrayelementen
glDrawElements(mode,count,type,pointer) g a e e ts( ode,cou t,type,po te ) - Sequenz Seque von vo Primitiven t ve mit t Indexliste de ste
Glfloat Corners[];
Glubyte y Indexes[]; []
glEnableClientState(
GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,
00,Corners); C )
glDrawElements(GL_QUADS,24,
GL_UNSIGNED_BYTE,Indexes);
Beispiele:
Glfloat *Data;
glEnableClientState(GL glEnableClientState(GL_VERTEX_ARRAY);
VERTEX ARRAY);
glVertexPointer(3,GL_FLOAT,0,Data);
glBegin(GL_TRIANGLES);
for(i=0;i

45
Programmbeispiele
Gluint Tisch,Tasse,Uhr,Lampe,Licht,Bild;
Tisch=glGenLists(1);
Tasse=glGenLists(1);
glCallList(Tisch);
glPushMatrix();
glScalef(0.6,0.6,0.0);
g
Uhr=glGenLists(1);
Lampe=glGenLists(1);
Bild=glGenLists(1);
g
glTranslatef(200,134,0);
glCallList(Tasse);
glPopMatrix();
glPushMatrix();
glNewList(Bild,GL_COMPILE);
glBegin(GL_POLYGON);
glColor3f(0.0,1.0,0.0);
glLineWidth(2);
glTranslatef(150,150,0);
glCallList(Uhr);
glPopMatrix();
glPushMatrix();
glVertex2f(0,0);
glVertex2f(15,0);
glVertex2f(15,10);
glVertex2f(8,6);
glTranslatef(50,88,0);
glutWireTeapot(10);
glPopMatrix();
glPushMatrix();
glVertex2f(2,8);
glVertex2f(0,12);
glEnd();
glEndList();
glTranslatef(90,160,0);
glScalef(2.6,2.6,0.0);
glCallList(Lampe);
glPopMatrix();
…
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(40,120,0);
glRotatef(8,0,0,1);
glScalef(1.6,1.6,0.0);
glCallList(Bild);
glPopMatrix();

46
Funktionsreferenz
glNewList - Beginn der Erzeugung oder Ersetzung einer Displayliste
glEndList - Beenden der Displayliste
glDeleteLists - Löschen einer Folge von Displaylisten
glCallList - Ausführen einer Displayliste
glCallLists - Ausführen mehrerer Displaylisten
glGenLists - Erzeugen einer Folge leerer Displaylisten
glIsList - Test auf Displayliste
glListBase - Festlegen eines Offsets für alle Displaylisten
glArrayElement - Verwendung eines einzelnen Arrayelements
glDrawArrays - Zeichnen einer Sequenz von Primitiven mit Arrayelementen
glDisableClientState - Nichtzulassen eines Arraytyps
glEnableClientState - Zulassen eines Arraytyps
glColorPointer - Definieren eines eines Vektors Vektors von Farbdaten
glDrawElements - Zeichnen einer Sequenz von Primitiven mit Indexliste
glDrawRangeElements - Zeichnen einer Folge von Primitiven eines Arrays
glMultiDrawElements - Zeichnen mehrerer Sequenzen von Primitiven mit Indexliste
glEdgeFlagPointer - Definition eines Arrays von Knotenflags
glIndexPointer - Definition eines Arrays aus Farbindexwerten
glInterleavedArrays - Zulassen von gleichzeitig mehreren Arraytypen
glNormalPointer - Definition eines Arrays Arrays von von Normalen
glTexCoordPointer - Definition eines Arrays von Texturkoordinaten
glVertexPointer - Definition eines Arrays von Scheitelpunkten

47
4. OpenGL: p Kurven und Flächen
Prof Prof. Dr.-Ing. Dr -Ing habil. habil Wolfgang Oertel
Ziele:
• Darstellung komplexer polygonaler Flächen
• Darstellung gekrümmter Kurven und Flächen
Abschnitte:
- Tessellatoren
- Quadriken Q
- Evaluatoren
- NURBS
Komplexe und gekrümmte Kurven und Flächen

48
Tessellatoren
TTessellatoren: ll Verfahren zur Unterteilung allgemeiner Polygone in einfache konvexe Polygone
Problem: OpenGL rendert nur einfache konvexe Polygone
Ei Einfache f h Polygone: P l kkein i SSchneiden h id von Kanten, K t keine k i doppelten d lt Kanten, K t nur 2 Kanten K t pro Knoten K t
Allgemeine Polygone: …
Lösung: Überführung von Polygonen
iin Kombinationen K bi ti von Dreiecken, D i k
Netzen, Fächern und Linien
1. Erzeugen eines Tessellations-Objektes:
Tessellations Objektes:
gluNewTess() liefert Pointer zu einem neuen Tessellations-Objekt
2. Registrierung von Callback-Funktionen:
gluTessCallback(*tessobj,type,(*fn)())
tessobj: erzeugtes Tessellations-Objekt
type: GLU_TESS_# oder GLU_TESS_#_DATA mit
#: BEGIN, EDGE EDGE_FLAG, FLAG, VERTEX, VERTEX, END, END, COMBINE, COMBINE, ERROR, ERROR,
fn: zu definierende Tessellations-Funktion
Mehrfacher Aufruf erforderlich (gegebenenfalls ohne Parameter)
Funktionsprototypen: begin(type), edgeFlag(flag), vertex(*vertex-data),
end(), d() error(errno), ( )
combine(coords[3],*vertex-data[4],weight[4],**outData)
bei DATA-Version zusätzlicher Parameter *user-data

49
3. Spezifikation von Tessellations-Eigenschaften:
gluTessProperty(*tessobj,property,value)
property: t GLU_TESS_BOUNDARY_ONLY AAussetzen t der d TTessellation ll ti
GLU_TESSTOLERANCE Abstand für Verschmelzung
GLU_TESS_WINDING_RULE Festlegung der zu füllenden Außenseite des Polygons
(GLU ( _TESS_WINDING _#
#: ODD, NONZERO, POSITIVE, NEGATIVE, ABS_GEQ_TWO)
gemäß Windungszahl (Anzahl der Umläufe um einen Punkt entgegen Uhrzeigersinn)
gluTessNormal(*tessobj,x,y,z) g ( j, ,y, )
1
Festlegen eines Normalenvektors
1
1
2
1
0
1
1 1
4. . Definition e t o von vo Polygonen: o ygo e :
gluTessBeginPolygon(*tessobj,*user-data) Beginn der Definition
mit Übergabe der Nutzerdaten
gluTessEndPolygon(*tessobj) Ende der Definition
mit it Anwendung A d der d Callback-Funktionen C llb k F kti für fü Erzeugen E undd Rendern R d
gluTessBeginContour(*tessobj) Beginn einer geschlossenen Kontur
gluTessEndContour(*tessobj) Ende einer geschlossenen Kontur
gluTessVertex(*tessobj,coords[3],*vertex-data) g ( j, [ ], ) Eckpunkt p mit Koordinaten
und Daten für Callback-Funktion (z.B. Koordinaten, Normalen, Texturkoordinaten, Farben)
5. Löschen eines Tessellations-Objektes:
gluDeleteTess(*tessobj) l D l t T (*t bj) Lö Löschen h des d Objektes Obj kt und d FFreigabe i b ddes SSpeicherplatzes i h l t
Objekte können für mehrere auch verschiedenartige Polygone verwendet werden

50
Programmbeispiel
GLdouble rect[4][3]={50 rect[4][3]={50.0,50.0,0.0,200.0,50.0,0.0,200.0,200.0,0.0,50.0,200.0,0.0};
0 50 0 0 0 200 0 50 0 0 0 200 0 200 0 0 0 50 0 200 0 0 0};
GLdouble tri[3][3]={75.0,75.0,0.0,125.0,175.0,0.0,175.0,75.0,0.0};
startList=glGenLists(1); tobj=gluNewTess();
gluTessCallback(tobj,GLU_TESS_VERTEX,vertexCallback);
gluTessCallback(tobj gluTessCallback(tobj,GLU_TESS_BEGIN,beginCallback);
GLU TESS BEGIN beginCallback);
gluTessCallback(tobj,GLU_TESS_END,endCallback);
gluTessCallback(tobj,GLU_TESS_COMBINE,combineCallback);
glNewList(startList,GL_COMPILE);
gluTessBeginPolygon(tobj gluTessBeginPolygon(tobj,NULL); NULL);
gluTessBeginContour(tobj);
gluTessVertex(tobj,rect[0],rect[0]);
gluTessVertex(tobj,rect[1],rect[1]);
gluTessVertex(tobj,rect[2],rect[2]);
gluTessVertex(tobj,rect[3],rect[3]);
gluTessEndContour(tobj);
gluTessBeginContour(tobj);
gluTessVertex(tobj,tri[0],tri[0]);
gluTessVertex(tobj,tri[0],tri[0]);
gluTessVertex(tobj,tri[1],tri[1]);
gluTessVertex(tobj,tri[2],tri[2]);
gluTessEndContour(tobj);
gluTessEndPolygon(tobj);
glEndList();
void beginCallback(GLenum which){glBegin(which);}
void endCallback(void){glEnd();}
( ){g ();}
void vertexCallback(GLvoid *vertex){glColor3d(1.0,0.0,1.0);glVertex3dv(vertex);}
void combineCallback(Gldouble coords[3],Gldouble *vertex_data[4],
GLfloat weight[4],GLdouble **dataOut) {. . . *dataOut=newvertex;}

51
Quadriken
QQuadriken: d ik Flächen im 3D Raum, die durch quadratische Gleichungen beschrieben werden können.
Es gibt vordefinierte Objekte und Funktionen zu deren Handhabung.
Vordefinierte Objekte:
Radius
Slices
(Längengrade)
Kugel:
gluSphere(*qobj,radius,slices,stacks)
g p q j, , ,
Erzeugung einer Kugel mit Mittelpunkt bei x=y=z=0
Stacks
(Breitengrade)
baseRadius
topRadius
slices
Zylinder, Kegelstumpf, Kegel:
gl gluCylinder(*qobj,baseRadius,topRadius,
C linder(*qobj baseRadi s topRadi s
height,slices,stacks)
Erzeugung eines offenen Zylinders im positiven Teil der z-Achse
mit Basiskreis in xy-Ebene y und Mittelpunkt p bei x=y=z=0 y
stacks
height
Null Grad
startAngle
outerRadius
sweepAngle
iinnerRadius R di
Scheibe, Scheibensegment:
gluDisk(*qobj,innerRadius,outerRadius,
slices slices,rings) rings)
gluPartialDisk(*qobj,innerRadius,outerRadius,
slices,rings,startAngle,sweepAngle)
Erzeugung g g von Scheibe oder Scheibensegment g in xy-Ebene y mit
Mittelpunkt bei x=y=z=0
slices
rings

52
Vorgehensweise:
1. Erzeugen eines Quardiks:
gluNewQuadric() Bereitstellen eines Pointers auf neue Datenstruktur für Quadrik-Objekt
2. Festlegen Festlegen von Rendering-Attributen:
Rendering Attributen:
gluQuadricDrawStyle(*qobj,drawStyle) Darstellungsart
style: GLU_FILL,GLU_LINE,GLU_POINT,GLU_SILHOUETTE
gluQuadricNormals(*qobj,normals) Art der Flächennormalen (keine, Fläche, Punkt)
normals: l GLU GLU_NONE,GLU_FLAT,GLU_SMOOTH
NONE GLU FLAT GLU SMOOTH
gluQuadricOrientation(*qobj,orientation) Orientierung der Flächennormalen
orientation: GLU_OUTSIDE,GLU_INSIDE
gluQuadricTexture(*qobj,textureCoords) g Q ( q j, ) Bereitstellen von Texturkoordinaten
textureCoords: GL_TRUE,GL_FALSE
3. Einbeziehung vordefinierter Objekte:
gluSphere gluSphere,gluCylinder,gluDisk,gluPartialDisk gluCylinder gluDisk gluPartialDisk als Displayliste
4. Löschen:
gluDeleteQuadric(*qobj) Löschen eines erzeugten Quadrik-Objektes
Beispiel: GLUquadricObj *qobj;
qobj=gluNewQuadric();
gluQuadricDrawStyle(qobj gluQuadricDrawStyle(qobj,GLU_FILL);
GLU FILL);
gluSphere(qobj,0.4,16,16);
gluDeleteQuadric(qobj);

53
Funktionsreferenz
gluNewTess - Erzeugen eines neuen Tessellators
gluTessCallback - Verbinden einer Funktion mit einem Tessellator
gluTessProperty - Setzen eines Eigenschaftswertes eines Tessellators
gluGetTessProperty - Bereitstellen eines eines Eigenschaftswertes Eigenschaftswertes eines eines Tessellators
gluTessNormal - Erzeugen eines Normalenvektors für einen Tessellator
gluTessBeginPolygon - Beginn der Spezifikation eines Polygons zur Tessellation
gluTessEndPolygon - Ende der Spezifikation p eines Polygons yg zur Tessellation
gluTessBeginContour - Beginn der Spezifikation einer Kontur als Polygonteil
gluTessEndContour - Ende der Spezifikation einer Kontur als Polygonteil
gluTessVertex - Spezifikation eines Eckpunktes in der aktuellen Kontur
gluDeleteTess - Löschen eines Tessellators
gluNewQuadric - Erzeugen eines Quadriks
gluDeleteQuadric - Löschen eines Quadriks
gluQuadricCallback - Definieren einer Funktion für Ausnahmefälle
gluQuadricDrawStyle - Steuern des Rendering-Stils für ein Quadrik
gluQuadricOrientation - Steuern der Orientierung der Normalen eines Quadriks
gluQuadricNormals gluQuadricNormals - Definition von von Normalen Normalen eines eines Quadriks
gluQuadricTexture - Generieren von Texturkoordinaten eines Quadriks
gluSphere - Zeichnen einer Kugel
gluCylinder - Zeichnen eines Zylinders
gluDisk - Zeichnen einer Scheibe
gluPartialDisk - Zeichnen einer partiellen Scheibe

54
Evaluatoren
Evaluatoren: Verfahren zur Spezifikation von von Punkten auf auf einer einer in der der Regel Regel gekrümmten gekrümmten Kurve
oder Fläche unter Verwendung von Kontrollpunkten. Die Kontrollpunkte definieren eine
polynomiale oder rationale Bezier-Kurve oder -Fläche.
Evaluatoren können verwendet werden zur Anzeige von Punkten, Linien, Gittern oder Flächen,
zur Berechnung von Normalenvektoren, Farbverläufen oder Texturkoordinaten
11. Definition von Evaluatoren:
Evaluatoren:
glMap1(target,u1,u2,stride,order,*points) 1D Evaluator
glMap2(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,*points)
2D Evaluator
target: GL_MAP#_VERTEX_3,GL_MAP#_VERTEX_4,GL_MAP#_INDEX,GL_MAP#_COLOR_4,
GL_MAP#_NORMAL,GL_MAP#_TEXTURE_COORD_1,GL_MAP#_TEXTURE_COORD_2,
GL_MAP#_TEXTURE_COORD_3,GL_MAP#_TEXTURE_COORD_4 (#: 1,2)
y y
u=1
u=0
u1 u1, u2 u2, v1 v1, v2: Variablenbereiche
Variablenbereiche
ustride, vstride: Anzahl der Werte für einen
Kontrollpunkt bzw. Abstand zwischen
zwei Kontrollpunkten p
uorder, vorder: Anzahl der Kontrollpunkte
bzw. Ordnung der Kurve (= Grad + 1)
points: Kontrollpunkte
u=0
v=00
x
u=1
z
x
v=1
z

55
2. Zulassen des Evaluators:
glEnable(target) Parameter wie in Punkt 1
3. Berechnung der Zielpunkte:
glEvalCoord1(u) Berechnen eines Punktes der Kurve
u ist beliebiger Wert zwischen u1 und u2
glEvalCoord2(u,v) Berechnen eines Punktes der Fläche
u, v sind beliebige Wert zwischen u1 und u2 bzw. v1 und v2
Verwendung konstanter konstanter Schrittweiten:
Schrittweiten:
glMapGrid1(n,u1,u2) Definition eines Rasters mit n gleichen Schritten von u1 bis u2
glMapGrid2(nu,u1,u2,nv,v1,v2) Definition eines Raster mit nu gleichen Schritten
von u1 bis bis u2 und nv gleichen gleichen Schritten von von v1 v1 bis v2 v2
glEvalMesh1(mode,i1,i2) Berechnen mehrerer Kurvenpunkte
glEvalMesh2(mode,i1,i2,j1,j2) Berechnen mehrerer Flächenpunkte
glEvalPoint1(i1) Berechnen eines eines Kurvenpunktes
glEvalPoint2(i1,j1) Berechnen eines Flächenpunktes
mode: GL_POINT, GL_LINE, GL_FILL
i1, i2, j1, j2: Bereich der darzustellenden Punkte zwischen 0 und nu bzw. 0 und nv
p1
p1
p3
p0 p1
p0
p2
p0 p2

56
Programmbeispiele
GLfloat ctrlPoints[4][3] = {{-4.0,0.0,0.0},{-6.0,4.0,0.0},
{6.0,-4.0,0.0},{4.0,0.0,0.0}};
glMap1f(GL_MAP1_VERTEX_3,0.0,1.0,3,4,&ctrlPoints[0][0]);
glEnable(GL_MAP1_VERTEX_3);
glBegin(GL_LINE_STRIP);
for(i=0; i

58
NURBS
NURBS: VVerfahren f h zur BBeschreibung h ib von Kurven K und d Flä Flächen, h die di sich i h durch d h hohe h h Stetigkeit St ti k it undd
lokale Definition bei großer Anzahl von Kontrollpunkten auszeichnen (Non-Uniform Rational B-Splines)
1. Generieren von Flächennormalen:
glEnable(GL_AUTO_NORMAL) Automatisches Generieren
2. Erstellen einer Datenstruktur:
gluNewNurbsRenderer() Bereitstellen eines Pointers auf eine neue Datenstruktur
3. Festlegen von Rendering-Attributen:
gluNurbsProperty(*nobj,property,value) Angabe von Eigenschaften und Werten
GLU_DISPLAY_MODE: _ _ GLU_FILL,GLU_OUTLINE_POLYGON,GLU_OUTLINE_PATCH
_ _ _ _ _
GLU_SAMPLING_METHOD: GLU_PATH_LENGTH,GLU_PARAMETRIC_ERROR
GLU_DOMAIN_DISTANCE
GLU_SAMPLING_TOLERANCE,GLU_PARAMETRIC_TOLERANCE
GLU GLU_U_STEP,GLU_V_STEP
U STEP GLU V STEP
GLU_CULLING,GLU_AUTO_LOAD_MATRIX
4./7. Beginn und Ende der Geometrieerzeugung:
gluBeginCurve(*nobj) Beginn einer Kurve Kurve
gluBeginSurface(*nobj) Beginn einer Fläche
gluEndCurve(*nobj) Ende einer Kurve
gluEndSurface(*nobj) Ende einer Fläche

59
5. Erstellen einer Kurve oder Fläche:
gluNurbsCurve(*nobj,uknotcount,*uknot,ustride,*ctlarray,uorder,type)
gluNurbsSurface(*nobj gluNurbsSurface(*nobj,uknotcount,*uknot,vknotcount,*vknot,ustride,
uknotcount *uknot vknotcount *vknot ustride
vstride,*ctlarray,uorder,vorder,type)
uknotcount Anzahl der Knoten des Knotenvektors
uknot Knotenvektor
ustride Anzahl der Werte für einen Kontrollpunkt
ctlarray Vektor der Kontrollpunkte
uorder Ordnung der Kurve
type Typ der Kontrollpunkte (GL_MAP1_VERTEX_3 (GL MAP1 VERTEX 3 bzw bzw. 4 4, …) )
alle Angaben für v analog, length(ctlarray) = uknot - uorder
6. Herausschneiden von Flächen (optional): ( p )
gluBeginTrim(*nobj) Beginn der Trimmkurve
gluPwlCurve(*nobj,count,*array,stride,type)
Erstellen der Trimmkurve
count Anzahl Anzahl der Punkte der der Kurve
array Punktvektor
stride Anzahl der Werte für einen Punkt
type yp Typ yp der Punkte
(GLU_MAP1_TRIM_2 oder 3)
gluEndTrim(*nobj) Ende der Trimmkurve
Äußere Kurve: Gegenuhrzeigersinn
umfasst gesamte Fläche
Innere Kurve: Uhrzeigersinn
umfasst auszuschneidende Fläche

60
Programmbeispiele
GLfloat ctrlPoints [4][4][3] =
{{{-6,-6,0},{-6,-2,0},{-6,2,0},{-6,6,0}},{{-2,-6,0},{-2,-2,8},...}}
GLfloat knots[8] = {0,0,0,0,1,1,1,1};
GLUnurbsObj *pNurb = NULL;
...
glEnable(GL_AUTO_NORMAL);
pNurb = gluNewNurbsRenderer();
gluNurbsProperty(pNurb,GLU_SAMPLING_TOLERANC,100.0); gluNurbsProperty(pNurb,GLU_DISPLAY_MODE,GLU_FILL);
gluBeginSurface(pNurb);
gluNurbsSurface(pNurb,8,knots,8,knots,4*3,3,&ctrlPoints[0][0][0],4,4,
GL_MAP2_VERTEX3); gluEndSurface(pNurb);
GLfloat outsidePts[5][2] = {{0.0,0.0},{1.0,0.0},{1.0,1.0},{0.0,1.0},{0.0,0.0}};
GLfloat curvePts[4][2] = {{0.25,0.5},{0.25,0.75},{0.75,0.75},{0.75,0.5}};
GLfloat curveKnots[8] = {0,0,0,0,1,1,1,1};
GLfloat pwlPts[3][2] = {{0.75,0.5},{0.5,0.25},{0.25,0.5}};
Innerhalb der NURBS-Fläche:
gluBeginTrim(pNurb);
gluPwlCurve (pNurb,5,&outsidePts[0][0],2,GLU_MAP1_TRIM_2);
gluEndTrim(pNurb);
gluBeginTrim(pNurb);
gluNurbsCurve (pNurb,8,curveKnots,2,&curvePts[0][0],4,GLU_MAP1_TRIM_2);
gluPwlCurve (pNurb,3,&pwlPts[0][0],2,GLU_MAP1_TRIM_2);
gluEndTrim(pNurb);

61
Funktionsreferenz
glMap1/2 / - DDefinition fi i i eines i 1/2D-Evaluators
1/2D E l
glEvalCoord1/2 - Evaluation eines 1/2D-Evaluators
glMapGrid1/2 - Definieren eines 1/2D-Rasters
glEvalMesh1/2 glEvalMesh1/2 - Evaluation eines eines 1/2D 1/2D-Rasters Rasters für für ein Netz
glEvalPoint1/2 - Evaluation eines 1/2D-Rasters für einen Punkt
gluNewNurbsRenderer - Erzeugen eines NURBS
gluDeleteNurbsRenderer - Lö Löschen h eines i NURBS NURBS
gluNurbsProperty - Steuern der Attribute eines NURBS
gluLoadSamplingMatrices - Verwenden spezieller Matrizen für die NURBS-Behandlung
gluGetNurbsProperty gluGetNurbsProperty - Bereitstellen von Attributwerten eines NURBS
gluNurbsCallback - Definition einer NURBS-Funktion zur Ausnahmebehandlung
gluBeginSurface - Beginn der Definition einer Fläche
gluEndSurface - Ende der Definition einer Fläche
gluNurbsSurface l b S f - BBeschreiben h ib dder GGestalt t lt einer i NURBS-Fläche
NURBS Flä h
gluBeginCurve - Beginn der Definition einer Kurve
gluEndCurve - Ende der Definition einer Kurve
gluNurbsCurve g
- Beschreiben der Gestalt einer NURBS-Kurve
gluBeginTrim - Beginn einer Trimm-Kurve
gluEndTrim - Ende einer Trimm-Kurve
gluPwlCurve - Beschreiben der Gestalt einer Trimm-Kurve

62
5. OpenGL: p Material und
Beleuchtung
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Modellierung von Oberflächen
• Modellierung g von Lichtquellen q
• Nachbildung der Wechselwirkung zwischen Beleuchtung und Oberfläche
Ab Abschnitte: h itt
- Farbmodell
- Schattierungsmodell
- Li Lichtquelle h ll
- Material
- Beleuchtungsmodell
- Normalenvektor
- Programmbeispiele
- Funktionsreferenz Material und Licht

63
Farbmodell
Farbmodell: definiert Datenstrukturen und Funktionen für Aufbau und Verwendung von
Farben auf dem Rechner
RGBA RGBA-Modell: Modell: Speicherung von von 3 (optional 4) 4) Werten für für jedes Pixel des des Farbpuffers: Farbpuffers:
Farbwerte Rot, Grün, Blau und Transparenzwert Alpha
Vorteile: Flexibilität, Unterstützung von komplexen Beleuchtungsmodellen, Nebel,
Antialiasing, g Blending g
Farbindex-Modell: Speicherung von 1 Wert für jedes Pixel des Farbpuffers:
Verweis auf Farbeintrag in Farbtabelle
(Farbtabelle vom Fenstersystem verwaltet, Zugriff über GLUT-Befehl)
Vorteil: Animationseffekte, Zeichenebenen, spezielle Anwendungen
Index:
G
Farbwürfel und Farbtabelle:
W
A
R
S
B
Farbpuffer: Speicher, der für jedes Pixel einen Farbwert enthält
- Bildschirmgröße (räumliche (räumliche Auflösung): Auflösung): 640x480 … 1600x1200
- Farbtiefe (radiometrische Auflösung): 4, 8, …, 24 Bit
- Farbkomponentenwerte liegen im Bereich [0.0,1.0] oder [0,255]

64
Befehle zu Arbeit mit Farben im RGBA-Modell:
Initialisieren der Fensterfarbe:
glutInitDisplayMode (GLUT_RGB) oder (GLUT_RGBA) Modus initialisieren
glClear (GL_COLOR_BUFFER_BIT) Puffer löschen
glClearColor (red,green,blue,alpha) Löschfarbe setzen
- Initialisierung: (0,0,0,0)
Setzen Setzen der aktuellen Farbe im im RGBA-Modus:
RGBA Modus:
glColor (red,green,blue,alpha)
- bleibt bis zur Umsetzung erhalten; alpha kann entfallen
- Werte für float (f) in [0.0,1.0], für integer (ub) in [0,255],
auch andere Datentypen möglich: (3,4), (b,d,f,i,s,ub,ui,us)
- 0: minimale Intensität, maximale Transparenz, 1: maximale Intensität, minimale Transparenz
- Initialisierung: (1,1,1,1)
Befehle für Farbindex-Modell:
glutInitDisplayMode (GLUT_INDEX)
glutSetColor (index,red,green,blue)
glClearIndex (index)
glIndex (index)
- Farbindex-Modell sollte nur für Spezialfälle verwendet werden

65
Schattierungsmodell
Schattierungsmodell: legt fest, wie eine ausgewählte Farbe zur Zeichnung der grafischen
Primitive verwendet wird
Zwei Schattierungsarten werden unterstützt:
- flache Schattierung: Verwendung einer Farbe für das gesamte Primitiv
(gemäß eines Punktes im Farbwürfel)
- glatte Schattierung: Schattierung: Interpolation zwischen zwischen den den Farben Farben der der Scheitelpunkte
Scheitelpunkte
(gemäß einer Linie oder Fläche im Farbwürfel)
glShadeModel (mode) Festlegen des Schattierungsmodells
mode: GL GL_FLAT FLAT flache flache Schattierung
GL_SMOOTH glatte Schattierung (initialer Wert)
f1 f2
W
G
G
f2
f1
S R
R
B
B

66
Lichtquelle
Lichtquelle: ist ein Objekt mit bestimmten geometrischen und optischen Charakteristika, das eine
Szene beleuchtet
Lichtquellen Lichtquellen besitzen einen einen Namen Namen und und unterscheiden unterscheiden sich durch: durch:
- Art der Quelle und Ausbreitung des Lichtes (Umgebungs-, Richtungs-, Punkt- und Spotlicht)
- Laterale Abschwächung des Lichtes (Grenzwinkel, exponentiell)
- Longitudinale Abschwächung des Lichtes (konstant, linear, quadratisch)
- AArt dder WWechselwirkung h l i k des d Lichtes Li h (diffus, (diff spiegelnd) i l d)
- Farbe des Lichtes (R,G,B,A)
- Position der Quelle (x,y,z) - Richtung des Lichtes (dx,dy,dz)
Quelle und
Ausbreitung:
Laterale
Abschwächung:
Longitudinale
Abschwächung:
Wechselwirkung:

67
Befehle zur Arbeit mit Lichtquellen:
glEnable (GL_LIGHTING) erlauben von Beleuchtungen
glEnable (GL_LIGHTi) Erzeugen einer Lichtquelle
- mindestens 8 Lichtquellen erlaubt: GL_LIGHTi (0=0, Initial 0
- GL_QUADRATIC_ATTENUATION quadratische Abschwächung des Lichtes, q>=0, Initial 0
1
2
c �
ld � qd

68
Material
Material: legt optische Eigenschaften der Oberfläche eines Polygons fest
Unterstützt Unterstützt werden werden ambiente ambiente, diffuse und spiegelnde Reflexion Reflexion sowie sowie Emission Emission.
glMaterial (face,pname,param) Festlegen von Materialeigenschaften der Oberfläche
- face: GL_FRONT, _ GL_BACK, _ GL_FRONT_AND_BACK
_ _ _
- GL_AMBIENT ambiente Farbe, (r,g,b,a), Initial (0.2,0.2,0.2,1.0)
- GL_DIFFUSE diffuse Farbe, (r,g,b,a), Initial (0.8,0.8,0.8,1.0)
- GL_AMBIENT_AND_DIFFUSE ambiente und diffuse Farbe gleichzeitig, (r,g,b,a)
- GL GL_SPECULAR SPECULAR spiegelnde spiegelnde Farbe Farbe, (r,g,b,a), (r g b a) Initial Initial (0,0,0,1) (0 0 0 1)
- GL_EMISSION Emissionsfarbe, (r,g,b,a), Initial (0,0,0,1)
e
- GL_SHININESS spiegelnder Exponent, e in [0,128], Initial 0
cos ( a)
- GL_COLOR_INDEXES Farbindexe für ambientes, diffuses und spiegelndes Licht, (i,j,k), Initial (0,1,1)
glColorMaterial (face,mode) Übernahme der aktuellen Farbe als Materialfarbe
- face: GL_FRONT, GLBACK, GL_FRONT_AND_BACK
- mode: GL_AMBIENT, GL_DIFFUSE, GL_AMBIENT_AND_DIFFUSE, GL_SPECULAR,
GL_EMISSION
- Voraussetzung: glEnable (GL_COLOR_MATERIAL)
glDisable (GL_COLOR_MATERIAL)
glSecondaryColor Explizites Setzen der Sekundärfarbe
glEnable(COLOR_SUM) Addieren der expliziten Sekundärfarbe nach der Texturierung

70
Beleuchtungsmodell
Beleuchtungsmodell: legt allgemeine Beleuchtungsparameter fest
Drei Beleuchtungsarten Beleuchtungsarten werden unterstützt.
Es ist kein globales Beleuchtungsmodell realisiert.
glLightModel (pname,param) Festlegen allgemeiner Beleuchtungsmodellparameter
- GL_LIGHT_MODEL_AMBIENT Umgebungslicht g g der gesamten g Szene, , (r,g,b,a), ( ,g, , ),
Initial (0.2,0.2,0.2,1.0)
- GL_LIGHT_MODEL_LOCAL_VIEWER Berechnungsmodus für spiegelnde Reflexionen, Initial 0,
0: bezüglich Betrachtung in negativer z-Richtung aus unendlicher Entfernung
11: bezüglich b ü li h Betrachtung B h vom Augpunkt A k
- GL_LIGHT_MODEL_TWO_SIDE ein- oder zweiseitige Beleuchtung von Polygonen, Initial 0,
0: nur Vorderseite
1: Vorder- Vorder und Rückseite Rückseite
- GL_LIGHT_MODEL_COLOR_CONTROL Steuerung von Primär- und Sekundärfarben
GL_SINGLE_COLOR: Primäre Farbe enthält alle Bestandteile
GL_SEPARATE_SPECULAR_COLOR: Spiegelnder Farbanteil wird in sekundäre Farbe abgelegt
L B L B

71
Beleuchtungsberechnung:
Farbe eines Punktes ergibt sich aus folgenden Lichtintensitäten getrennt nach R, G, B:
Summe aus:
- Materialemission
- Produkt aus: aus: - Materialumgebungsreflexion
- Szenenumgebungslicht
- Beitrag des Lichtes jeder Lichtquelle
Summe aus:
- Produkt aus: - Materialumgebungsreflexion
- Quellenumgebungslicht
- Produkt aus: - Materialdiffusreflexion
- Quellendiffuslicht
- Produkt aus Flächennormale und Quellenrichtung
- Produkt aus: - Materialspiegelreflexion
- Quellenspiegellicht
- potenziertes Produkt aus Betrachterrichtung und Reflexionsrichtung
Negative Werte werden auf 0 gesetzt
Alle Lichtintensitäten werden multipliziert mit
- richtungsabhängigen Faktoren
- entfernungsabhängigen Faktoren
Resultierende Farbe wird mit Alpha-Wert A der Materialdiffusreflexion multipliziert

72
Normalenvektor
Normalenvektor: Vektor, der in eine Richtung zeigt, die senkrecht zu einer Oberfläche ist
- Normalenvektoren werden für die Eckpunkte p von Primitiven definiert.
- Indirekt können sie einer Fläche zugeordnet werden.
- Sie werden benötigt, um die Berechnung der Beleuchtung durchführen zu können.
- Die Vektoren müssen für die Berechnung normiert vorliegen.
- NNormalisierung li ie manuell ell oder de automatisch t ti h möglich. ö li h
glNormal (nx,ny,nz) Setzen des aktuellen Normalenvektors, Initial: (0,0,1)
glEnable (GL_NORMALIZE) führt eine Normalisierung der Vektoren durch
Berechnung von Normalenvektoren:
Normalenvektor eines Polygons: yg
- Ausgangspunkt: 3 Punkte der Ebene: v1, v2, v3
- Berechnung des Kreuzproduktes [v3-v1] x [v2-v1]
Durchschnittsvektoren mehrerer Polygone:
- AAusgangspunkt: kt VVektoren kt n1, 1 n2, 2 …
- Addieren der Vektoren (ggf. mit Wichtung): n1+n2+…
Normalisierung eines Vektors:
- Ausgangspunkt: g g p Vektor n=(x,y,z) ( ,y, )
- Division jeder Komponente x, y, z durch Länge des
Vektors sqrt(x*x)+(y*y)+(z*z))

73
Programmbeispiele
void main(void){
glutInitDisplayMode(
GLUT_SINGLE|GLUT_RGB);
. . .} }
void reshape(void){
. . .}
void init(void){
glClearColor(0.0,0.0,0.0,0.0);
glShadeModel(GL_SMOOTH);}
void display(void){
p y( ){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLES);
glColor3f(1.0,0.0,0.0); glVertex2f(5.0,5.0);
glColor3f(0.0,1.0,0.0); g ( , , ) g glVertex2f(25.0,5.0);
( , )
glColor3f(0.0,0.0,1.0); glVertex2f(5.0,25.0);
glEnd(); glFlush();}
glBegin(GL_POLYGON);
glNormal3fv(n0);
glVertex3fv(v0);
glNormal3fv(n1);
glVertex3fv(v1);
glNormal3fv(n2);
glVertex3fv(v2);
glNormal3fv(n3);
glVertex3fv(v3);
glEnd();
void init(void){
GLfloat mat_specular[]={1.0,1.0,1.0,1.0};
GLfloat mat_shininess[]={50.0};
GLfloat light_position[]={1.0,1.0,1.0,0.0};
glClearColor(0.0,0.0,0.0,0.0);
g
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMaterialfv(GL g _FRONT,GL_SPECULAR,mat_specular); p
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
glLightfv(GL_LIGHT0,GL_POSITION,light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);} void display(void){
glClear(GL_COLOR_BUFFER_BIT);
glutSolidSphere(1.0,20,16); glFlush();}

74
Funktionsreferenz
glClear - Zurücksetzen des Farbpuffers u.a.
glClearColor - Setzen der Fensterlöschfarbe im RGBA-Modus
glClearIndex - Setzen der Fensterlöschfarbe im Farbindex-Modus
glColor - Setzen der aktuellen Farbe im RGBA-Modus
glSecondaryColor - Explizites Setzen der Sekundärfarbe
glColorMask - Erlauben von Veränderungen der Farbkomponenten im Farbpuffer
glColorMaterial - Gestattet als als Materialfarben Materialfarben die aktuelle Farbe zu verwenden verwenden
glCullFace - Angabe der nicht zu berücksichtigenden Seite eines Polygons
glEnable - Erlauben von Farb- und Lichteigenschaften u.a.
glFrontFace - Festlegen der Vorderseite eines Polygons
glGetMaterial - Liefern der aktuellen Materialeigenschaften
glGetLight - Liefern von Informationen über die aktuellen Lichtquellen
glIndex - Setzen der aktuellen Farbe im Farbindex-Modus
glLight - Setzen von Parametern einer Lichtquelle
glLightModel - Festlegen des Beleuchtungsmodells
glMaterial - Festlegen von Materialparametern
glNormal - Festlegen der Flächennormalen
glShadeModel - Festlegen des Schattierungsmodells
glutInitDisplayMode - Festlegen des Farbmodells u.a.
glutSetColor - Laden eines Farbindexes in die Farbtabelle

75
6. OpenGL: p Bitmaps, p , Bilder
und Texturen
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Behandlung von Bitmaps und Bildern
• Abbildung von Texturen auf Objekte
Abschnitte:
- Zeichnen von Bitmaps
- Lesen und Schreiben von Bildern
- Operationsmodi für für Bilder
- Verwenden von Texturobjekten
- Erzeugen von Texturobjekten
- Binden von Farben und Koordinaten
- Programmbeispiele
- Funktionsreferenz Pixel und deren Operationen

76
Zeichnen von Bitmaps
Bitmap: rechteckiges Feld mit binären Werten 1 und 0, das als Zeichenmaske für einen rechteckigen
Fensterbereich dient
Anwendung: Anwendung: Erzeugung von Bildschirmmustern
Darstellung von Zeichen in Fonts
Bildung von Zeichenketten über Displaylisten
Setzen der Rasterposition:
glRasterPos(x,y,z) Festlegung der aktuellen Koordinaten x, y, z
müssen innerhalb des Clipping-Bereiches liegen
Koordinaten wie Scheitelpunkte behandelt (Transformation, Projektion)
Speicherung in GL_CURRENT_RASTER_POSITION (Zugriff mit glGetFloatv())
Zeichnen eines Bitmaps:
glBitmap(width,height,xbo,ybo,xbi,ybi,*bitmap)
Zeichnen eines Bitmap an aktuelle Rasterposition mit Angaben zu
Breite und Höhe des Bitmaps in Pixel
Ursprung im Bitmap in Pixel (von links unten)
Inkrement des Rasters in Pixel bezüglich Rasterposition
Speicherung des Bitmaps in Vielfachen von 8 Bit
Bitmap parallel zur xy-Ebene des Framebuffers gezeichnet
Wert 1: Pixel wird auf aktuelle Rasterfarbe gesetzt
Wert 0: Pixel bleibt unverändert

77
Farbe eines Bitmaps:
glColor() Setzen der der Farbe Farbe für das das Bitmap;
Aufruf vor glRasterPos()
Speicherung in GL_CURRENT_RASTER_COLOR (Zugriff mit glGetFloatv())
Zeichen und Fonts:
Font als Menge von Zeichen mit Zahl und Bitmap
Zeichenketten als Folge von Zeichen
glListBase(base) Festlegen eines Offsets für den Font
glGenLists(range) Erzeugen von Listennummern für Zeichen
glNewList(list mode) Einbinden eines Zeichens eines externen Fonts
glEndList() Beenden der Zeichendefinition
glCallList(list) Zeichnen eines Zeichens
glCallLists(n,type,*lists) Zeichnen einer Zeichenkette
glDeleteLists(list,range) Löschen eines Fonts

78
Lesen und Schreiben von Bildern
Bild: rechteckiges Feld von Pixel, wobei jedes Pixel komplette RGBA-Information enthalten kann
Herkunft von Bildern: - über Scanner oder Kamera digital bereitgestellt
- von anderem Grafikprogramm auf Bildschirm erzeugt
- von Programm im Speicher generiert
Lesen eines Bildes:
glReadPixels(x,y,width,height,format,type,*pixels)
Lesen eines rechteckigen Feldes von Pixel vom Framebuffer zum Speicher
Schreiben eines Bildes:
glDrawPixels(width,height,format,type,*pixels)
Schreiben eines rechteckigen Feldes von Pixel vom Speicher zum Framebuffer an Rasterposition
Kopieren p eines Bildes:
glCopyPixels(x,y,width,height,buffer)
Kopieren eines rechteckigen Feldes von Pixel vom Framebuffer zum Framebuffer an Rasterposition
Format: GL_COLOR_INDEX, GL_RGB, GL_GRBA, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA
GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT
Type: GL_UNSIGNED_BYTE, GL_BYTE
GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT
GL GL_UNSIGNED_INT, UNSIGNED INT GL GL_INT, INT GL GL_FLOAT FLOAT
Buffer: GL_COLOR, GL_DEPTH, GL_STENCIL

79
Operationsmodi für Bilder
Pixel-Speichermodus:
glPixelStore(pname,param)
GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH,
GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS, GL_PACK_ALIGNMENT,
analog UNPACK
Pixel-Transferoperationen:
glPixelTransfer(pname,param)
GL_MAP_COLOR, GL_MAP_STENCIL, GL_INDEX_SHIFT, GL_INDEX_OFFSET,
GL GL_RED_SCALE, RED SCALE GL GL_GREEN_SCALE, GREEN SCALE GL GL_BLUE_SCALE, BLUE SCALE GL_ALPHA_SCALE,
GL ALPHA SCALE
GL_DEPTH_SCALE, GL_RED_BIAS, GL_GREEN_BIAS, GL_BLUE_BIAS,
GL_ALPHA_BIAS, GL_DEPTH_BIAS
Pixel Pixel-Mapping: Mapping:
glPixelMap(map,mapsize,*values)
GL_PIXEL_MAP_I_TO_I, … S_TO_S, I_TO_R, I_TO_G, I_TO_B, I_TO_A,
R_TO_R, G_TO_G, B_TO_B, A_TO_A Skalierung:
glPixelZoom(zoomx,zoomy)
Vergrößerung g g und Verkleinerung g (auch ( Spiegelung) p g g)
des Bildes

80
Verarbeitungs-Pipeline:

81
Programmbeispiele
GLubyte rasters[24]={0xc0 rasters[24] {0xc0,0x00,0xc0,0x00,0xc0,0x00,0xc0,0x00,0xc0,0x00,
0x00 0xc0 0x00 0xc0 0x00 0xc0 0x00 0xc0 0x00
0xff,0x00,0xff,0x00,0xc0,0x00,0xc0,0x00,0xc0,0x00,0xff,0xc0,0xff,0xc0};
void init(void){
glPixelStorei(GL_UNPACK_ALIGNMENT,1); glClearColor(0.0,0.0,0.0,0.0);}
void display(void){
glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0,1.0,1.0);
glRasterPos2i(20,20);
glBitmap(10 glBitmap(10,12,0.0,0.0,11.0,0.0,rasters);
12 0 0 0 0 11 0 0 0 rasters);
glBitmap(10,12,0.0,0.0,0.0,13.0,rasters);
glFlush();}
GLubyte chImage[64][64][3];
void makeChImage(void{
int i,j,c;
for(i=0;i

82
Funktionsreferenz
glBitmap - Zeichnen eines Bitmaps
glCopyPixels - Kopieren von Pixel im Framebuffer
glDrawBuffer glDrawBuffer - Festlegen eines eines Farbpuffers Farbpuffers für für das das Schreiben von Pixel
glDrawPixels - Schreiben eines Blocks von Pixel in den Framebuffer
glGetPixelMap - Bereitstellen eines spezifizierten Pixelmaps
glPixelMap - Definieren von Maps für den Transfer von Pixel
glPixelStore - Festlegen von Modi für das Speichern von Pixel
glPixelTransfer - Festlegen von Modi für den Transfer von Pixel
glPixelZoom - Setzen der Skalierungsfaktoren für Pixel
glRasterPos - Setzen der Koordinaten der aktuellen aktuellen Rasterposition
glReadBuffer - Festlegen eines Farbpuffers für das Lesen von Pixel
glReadPixels - Lesen eines Blocks von Pixel aus dem Frame Buffer

84
Verwenden von Texturobjekten
Textur: ein- oder zweidimensionales Muster, das einem geometrischen Objekt zugeordnet und
mit diesem verändert und angezeigt wird
SSchritte h itt ddes TTexture t MMappings: i
- Erzeugen eines Texturobjektes und Spezifizierung der Textur für das Objekt
- Festlegen, wie die Textur für jedes Pixel anzuwenden ist
- EErlauben l b des d Texture T Mappings M i undd
Zeichnen der Szene mit Textur und geometrischen Koordinaten
Aktivieren des Texture Texture Mappings:
glEnable(GL_TEXTURE_2D)
Aktivierung und Darstellung des Objektes in der Szene
(auch GL GL_TEXTURE_1D)
TEXTURE 1D)

85
Erzeugen von Texturobjekten
Definition eines Texturobjekts:
glTexImage2D(target,level,components,width,height,border,format,
type type,*pixels) *pixels)
target GL_TEXTURE_2D
level Detaillierungsniveau (Mipmap): z.B. 0,1,2,3,4
components Anzahl der Farbkomponenten: z.B. 1,2,3,4
width, height Breite und Höhe des Texture-Image
border Größe des Randbereiches der Texturen (wichtig für weiche Übergänge), z.B. 0
format Format der Pixeldaten, z.B. GL_RGBA
type Datentyp Datentyp des Pixelwertes Pixelwertes, z.B. z B GL GL_UNSIGNED_BYTE
UNSIGNED BYTE
pixels Zeiger auf die Textur-Daten
Festlegen g von Texturparametern:
p
glTexParameter(target,pname,param)
target GL_TEXTURE_2D
GL_TEXTURE_MIN_FILTER Minification-Filter: GL_NEAREST, GL_LINEAR oder
GL_X_MIPMAP_Y mit x, y: LINEAR,NEAREST
(ein Pixel für mehrere Texturelemente)
GL_TEXTURE_MAG_FILTER Magnification-Filter: GL_NEAREST oder GL_LINEAR
(ein Texturelement Texturelement für für mehrere mehrere Pixel)
GL_TEXTURE_WRAP_{S T} Behandlung der S- oder T-Texturkoordinaten außerhalb
des Bereiches 0...1: GL_REPEAT oder GL_CLAMP

86
Bindung von Farben und Koordinaten
Festlegen der Texturumgebung (Farbdarstellung):
glTexEnv(target,pname,param)
target g GL_TEXTURE_ENV GL_TEXTURE_ENV_MODE
GL_MODULATE Texturwerte werden mit Objektwerten multipliziert
GL_DECAL Texturwerte überschreiben Objektwerte (3, 4)
GL GL_BLEND BLEND TTexturwerte t t werden d mit it Farbe F b gemischt i ht (1, (1 2) 2)
GL_TEXTURE_ENV_COLOR Zeiger auf einen RGBA-Wert (1, 2)
abhängig von Anzahl der Textur-Komponenten (1, 2, 3, 4)
target g GL_POINT_SPRITE GL_COORD_REPLACE GL_TRUE Zulassung von Point Sprites
Binden der Texturkoordinaten (manuell):
glTexCoord(coords) (Texturobjektkoordinaten)
1: s-Koordinate (Horizontale)
2: s- Koordinate und t-Koordinate (Vertikale)
3: s- Koordinate, t-Koordinate und r-Koordinate (Tiefe)
4: s- Koordinate, t-Koordinate, r-Koordinate und q-Koordinate (Homogene, Zeit)
glVertex(coords) (Szenenobjektkoordinaten)
x-Koordinate di und d y-Koordinate di
x-Koordinate, y-Koordinate, z-Koordinate

87
Binden der Texturkoordinaten (automatisch):
glTexGen(coord,pname,param) (allgemein für Objekte)
coord: GL_S, GL_T, GL_R oder GL_Q
pname, param:
GGL_TEXTURE_GEN_MODE G O
GL_OBJECT_LINEAR objektabhängige Texturgenerierung aus Vertexkoordinaten
GL_EYE_LINEAR betrachterabhängige Texturgenerierung aus Augpunktkoordinaten
GL_SPHERE_MAP Texturgenierung g g über kugelförmiges g g Umgebungsmapping
g g pp g
GL_OBJECT_PLANE
p1,p2,p3,p4 Ebenendefinition für objektabhängige Texturgenerierung
GL_EYE_PLANE
p1,p2,p3,p4 1 2 3 4 Eb Ebenendefinition d fi iti für fü betrachterabhängige b t ht bhä i Texturgenerierung
T t i
Einschaltung der Generierung für jede Dimension über glEnable(GL_TEXTURE_GEN_S)
gluQuadricTexture(*qobj,textureCoords) g Q ( q j, ) (speziell ( p für Quadrics) Q )
textureCoords: GL_FALSE,GL_TRUE
Arbeit mit Texturobjekten: j
glGenTextures(n,*texNames) Bereitstellen freier Objektnamen
glBindTexture(target,texName) Erzeugen, Aktivieren, Deaktivieren eines Objektes
glDeleteTextures(n,*texNames) Löschen von Texturobjekten j

88
Programmbeispiele
static Glubyte Glubyte chImage[64][64][4];
chImage[64][64][4];
static Gluint texName;
void init(void){
glClearColor(0.0,0.0,0.0,0.0);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glGenTextures(1,&texName);
glBindTexture(GL_TEXTURE_2D,texName);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,64,64,0,GL_RGBA,GL_UNSIGNED_BYTE,
chImage);}
void display(void){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_DECAL);
glBindTexture(GL glBindTexture(GL_TEXTURE_2D,texName);
TEXTURE 2D texName);
glBegin(GL_QUADS);
glTexCoord2f(0.0,0.0); glVertex3f(-2.0,-1.0,0.0);
glTexCoord2f(0.0,1.0); glVertex3f(-2.0,1.0,0.0);
glTexCoord2f(1 glTexCoord2f(1.0,1.0); 0 1 0); glVertex3f(0 glVertex3f(0.0,1.0,0.0);
0 1 0 0 0);
glTexCoord2f(1.0,0.0); glVertex3f(0.0,-1.0,0.0);
glEnd(); glFlush();
glDisable(GL_TEXTURE_2D);}

89
Funktionsreferenz
glAreTexturesResident - Abragen des Residenzstatus für Texturobjekte
glBindTexture - Binden von Texturnamen an Targets
glCopyTexImage2D - Kopieren eines Bildes aus Framebuffer in 2D Texturobjekt (auch 1D)
glCopyTexSubImage2D - Kopieren eines Teilbildes aus aus Framebuffer Framebuffer in Texturobjekt (auch (auch 1D) 1D)
glDeleteTextures - Löschen von benannten Texturobjekten
glGenTextures - Erzeugen von neuen Namen für Texturobjekte
glGetTexEnv - Bereitstellen von Parametern der Texturumgebung g g
glGetTexGen - Bereitstellen von Parametern der Texturkoordinatengenerierung
glGetTexImage - Bereitstellen eines Texturbildes
glGetTexLevelParameter - Bereitstellen von Texturparametern eines Detaillierungsniveaus
glGetTexParameter - Bereitstellen von von Texturparameterwerten
Texturparameterwerten
glIsTexture - Test, ob Name eine Textur ist
glPrioritizeTextures - Zuweisen von Residenzprioritäten an Texturobjekte
glTexCoord - Setzen der aktuellen Texturkoordinaten
glTexCoordPointer - Definition eines Feldes von Texturkoordinaten
glTexEnv - Setzen von Parametern der Texturumgebung
glTexGen - Steuern der Erzeugung von Texturkoordinaten
glTexImage2D - Spezifikation eines eines 2D 2D Texturbildes Texturbildes (auch (auch 1D)
glTexParameter - Setzen der von Texturparametern
glTexSubImage2D - Spezifikation eines 2D Texturteilbildes (auch 1D)
gluScaleImage - Skalieren eines eines Bildes
gluBuild2DMipmaps - Erzeugen eines 2DMipmaps (auch 1D)
gluQuadricTexture - Spezifikation der Texturierung von Quadrics

90
7. OpenGL: p Effekte, , Puffer und
Interaktion
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Nachbehandlung von erzeugten Grafiken
• Arbeit mit Speicherbereichen
• Steuerung der Interaktion Interaktion mit dem dem Nutzer Nutzer
Abschnitte:
Externe Schnittstelle
- Blending
- Antialiasing
- Fogg
- Pufferstrukturen
- Pufferoperationen
- Accumulation
- SSelection l ti
- Feedback
- OpenGL Zustandsvariablen

91
Blending
Blending: Erzeugen von Transparenz durch Vermischen von unterschiedlichen Farbwerten
Vorgehensweise:
- Verwendung Verwendung von von Alpha Alpha-Werten Werten im RGBA RGBA-Modus Modus
- Zulassen der Vermischung: glEnable(GL_BLEND)
- Definieren der Blendfaktoren für Quelle und Ziel: glBlendFunc(sfactor,dfactor)
Quelle: Farbwert für aktuelles aktuelles Objekt Objekt, Ziel: Ziel: Farbwert Farbwert im Framebuffer
- Setzen von Farben und Zeichnen von Objekten: glColor, glVertex, …
Berechnungsausdruck: (RsSr+RdDr, GsSg+GdDg, BsSb+BdDb, AsSa+AdDa)
BBegrenzung dder Ergebnisse E b i auf f [0,1] [0 1] bzw. b auff Farbwertebereich
F b b i h
Parameterwerte: (sfactor, dfactor) (mit Division durch maximalen Farbwert)
GL_ZERO (0,0,0,0) GL_ONE (1,1,1,1)
GL_DST_COLOR (Rd,Gd,Bd,Ad) GL_SRC_COLOR (Rs,Gs,Bs,As)
GL_ONE_MINUS_DST_COLOR (1,1,1,1)-(Rd,Gd,Bd,Ad) GL_ONE_MINUS_SCR_COLOR (1,1,1,1)-(Rs,Gs,Bs,As)
GL_SRC_ALPHA (As,As,As,As) GL_DST_ALPHA (Ad,Ad,Ad,Ad)
GL_ONE_MINUS_SRC_ALPHA (1,1,1,1)-(As,As,As,As) GL_ONE_MINUS_DST_ALPHA (1,1,1,1)-(Ad,Ad,Ad,Ad)
GL_SRC_ALPHA_SATURATE (min(As,1-Ad),min(As,1-Ad),min(As,1-Ad),1)
R, G, B, A
Quelle (S):
R, G, B, A
Ziel (D):
Beispiele:
- Default: (GL_ONE, GL_ZERO)
- Transparenz: (GL (GL_SRC_ALPHA, SRC ALPHA GL GL_ONE_MINUS_SRC_ALPHA)
ONE MINUS SRC ALPHA)
- Überlagerung zweier oder mehrerer Bilder
- Verwendung von Farbfiltern

92
Antialiasing
Antialiasing: Veränderung der Farbwerte zur Glättung von Punkten, Linien und Polygonen
Vorgehensweise:
- Problem: Problem: Schräge Schräge Linien werden werden wegen wegen der der Rasterung mit Sprüngen Sprüngen angezeigt angezeigt
- Aufgabe: Nutzung der Blending-Technik, um Sprünge sichtbar zu glätten
- Zulassung der Glättung: glEnable(GL_POINT_SMOOTH), glEnable(GL_LINE_SMOOTH),
glEnable(GL_POLYGON_SMOOTH)
- OpenGL speichert den Überdeckungsgrad eines Pixels im zugehörigen Alpha-Wert
- Alpha-Wert kann im Rahmen der Blending-Funktion verwendet werden:
glEnable (GL_BLEND), glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
- Einfache Alternative: Funktion glHint
- Steuerung des Systemverhaltens: glHint(target,hint)
Verhalten implementationsabhängig
hint: GL GL_FASTES, FASTES GL GL_NICEST, NICEST GL GL_DONT_CARE
DONT CARE
target: GL_POINT_SMOOTH_HINT, GL_LINE_SMOOTH_HINT, GL_FOG_HINT,
GL_POLYGON_SMOOTH_HINT, GL_PERSPECTIVE_CORRECTION_HINT

93
Fog
Fog: Atmosphärische Effekte durch Abschwächung von Objekten entsprechend ihrer Entfernung
Vorgehensweise:
- Objekte Objekte werden werden mehr mehr und mehr mit Farbe Farbe des Nebels überblendet bis bis zur Unsichtbarkeit
(depth-cuing)
- Vorteile: realistischere und effizientere Darstellung
- Zulassung von Nebel: glEnable(GL_FOG)
- Steuerung des Systemverhaltens: glFog(pname,param)
pname: GL_FOG_MODE, GL_FOG_DENSITY, GL_FOG_START, GL_FOG_END,
GL_FOG_INDEX, GL_FOG_COLOR
param: Modus oder zugehörige Werte: GL_EXP, GL_EXP2, GL_LINEAR
� z
start
end
end �
�
f
2
)
( density�z
�
e
�
f
)
( density�z
f
�
f � e
c � fc ��
( 1 1�
f ) c
Farb Farb- oder Indexwerte: Indexwerte:
i
Default: GL_EXP, 1, 0, 1, 0, (0,0,0,0)
100
0 1

94
Pufferstrukturen
Puffer: Speicher, der für alle Pixel eines Fensters eine einheitliche Datenstruktur bereitstellt
Fenster
Pixel
x
1.0 2.0 3.0
0.0
Vorgehensweise:
- Abbildung g von Fragmenten g mit ggeometrischen
Parametern y
auf Pixel mit Position und Farbe
3.0
- Pixeldaten werden in unterschiedlichen Puffern abgelegt
- Jeder Puffer hat seine eigene Struktur und Funktion
2.0
- ttypische i h Puffergröße: P ff öß 1280 1280 x 1024 x 24bit
1.0
- alle Puffer zusammen bilden den Framebuffer
- Farbpuffer ist der einzige direkt sichtbare Puffer
0.0
- Pufferparameter p implementationsabhängig, p g g, Abfrage g möglich g
Pufferarten:
- Farbpuffer p ( (color): ) dient dem Zeichnen; ; enthält RGBA- G oder Farbindexwerte; ; front-left für
Mono-Einzel-Pufferung, front-right für Stereo-Pufferung, back-left und back-right für
Doppel-Pufferung, auxiliary(i) für Hilfspufferung
- Tiefenpuffer p ( (depth, p , z): ) speichert p Tiefenwerte, , senkrecht zu xy-Ebene, y , Werte von Objekten j mit
geringstem Abstand zum Auge, tiefer liegende Objekte entfallen
- Schablonenpuffer (stencil): beschränkter Bildschirmbereich; unabhängige Verwaltung von
Schablonenbereich und Umgebung; g g; Sicherheit und Effizienz
- Akkumulatorpuffer (accumulator): enthält RGBA-Werte; dient der Sammlung von Teilbildern
und deren Zusammensetzung zu einem kompositen Bild vor Übertragung zum Farbpuffer

95
Pufferoperationen
Lö Löschen: h
- festlegen der Initialwerte, die beim Löschen der einzelnen Puffer angewendet werden
glClearColor(red,green,blue,alpha) glClearIndex(index)
glClearDepth(depth) glClearStencil(s)
glClearAccum(red,green,blue,alpha)
- Löschen eines oder mehrerer Puffer
glClear(mask)
mask: bitweise Oder-Verknüpfung aus GL_*_BUFFER_BIT, mit
*: COLOR, DEPTH, STENCIL, ACCUM
Auswahl:
- festlegen eines Farbpuffers für Schreiben und Lesen
glDrawBuffer(mode) nachfolgend alle Zeichenoperationen wie glDrawPixels, glRasterPos
glReadBuffer(mode) nachfolgend Operationen wie glReadPixels, glCopyPixels
mode: GL GL_FRONT FRONT (Default) (Default), GL GL_LEFT, LEFT …
Maskieren:
- festlegen einer Maske für einen Puffer, die beim Schreiben mit dem aktuellen Wert
über bitweises Und Und verknüpft verknüpft wird wird
glIndexMask(mask) glColorMask(red,green,blue,alpha)
glDepthMask(flag) glStencilMask(mask)
Argumente: GL_TRUE, GL_FALSE

96
Testoperationen:
alle Tests müssen mit glEnable zunächst zugelassen werden
sie verhindern oder ermöglichen das Schreiben einzelner Fragmente
- Scissor-Test: Test auf ein Schnittrechteck
glScissor(x,y,width,height)
- Alpha Alpha-Test: Test: Test Test auf auf Alpha-Wert Alpha Wert
glAlphaFunc(func,ref)
func: GL_NEVER, GL_ALWAYS, GL_LESS, GL_EQUAL, GL_GREATER, GL_LEQUAL,
GL_GEQUAL, GL_NOTEQUAL; ref: Referenzwert
- Stencil-Test: Test auf eine Schablone und zugehörige Operation im Stencil-Puffer
glStencilFunc(func,ref,mask)
func: ...; Ref: ...; mask: bit-Werte
glStencilOp(fail glStencilOp(fail,zfail,zpass)
zfail zpass)
Parameter: GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT
- Depth-Test: Tiefentest
glDepthFunc(func) func: …, Default: GL_LESS
glEnable(GL_DEPTH_TEST) Verwendung des Tiefentests
Verknüpfungsoperationen: aktuelles Fragment (Quelle) mit Farbpuffer (Ziel):
- Bl Blending: di ffarbspezifische b ifi h logische l i h Operation O ti
glEnable(GL_BLEND) glBlendFunc(sfactor,dfactor)
- Dithering: Verbesserung der Farbauflösung auf Kosten der räumlichen Auflösung
glEnable(GL g _DITHER)
- Logic: beliebige bitweise logische Operation
glEnable(GL_#_LOGIC_OP) #: INDEX,COLOR glLogicOp(opcode)
opcode: GL_CLEAR, GL_COPY, GL_SET, GL_AND, GL_OR, GL_INVERT, …

97
Akkumulatoroperationen:
- Akkumulatorpuffer wird nicht automatisch beschrieben.
beschrieben.
- Er kann als Zwischenspeicher verwendet werden.
glAccum(op,value)
op: GL_ACCUM: Liest den Pixelwert vom Farbpuffer, multipliziert diesen mit der Zahl und
addiert ddi ddas EErgebnis b i zum Akkumulatorwert
Akk l
GL_LOAD: Liest den Pixelwert vom Farbpuffer und schreibt den mit der Zahl multiplizierten
Pixelwert in den Akkumulator
GL GL_RETURN: RETURN: Schreibt Schreibt den den mit der der Zahl Zahl multiplizierten multiplizierten Akkumulatorwert Akkumulatorwert in den den Farbpuffer Farbpuffer
GL_ADD: Addition des Akkumulatorwertes mit der Zahl
GL_MULT: Multiplikation des Akkumulatorwertes mit der Zahl
value: Gleitkommazahl
- NNur Pi Pixel l in i der d aktuellen kt ll Scissor-Box S i B werden d verändert. ä d t
- Anwendungen:
- Szenen Antialiasing
- Bewegungsunschärfe
- Tiefenunschärfe
- Weiche Schatten
- Jitt Jittering i (Antialiasing (A ti li i durch d h Mehrpassrendering
M h d i
mit veränderter Kameraposition)

98
Funktionsreferenz
glBlendFunc - Kombination von Farbwerten mit den Farbwerten im Framebuffer
glHint - Steuerung implementationsspezifischen Verhaltens
glFog - Spezifikation von Nebelparametern
glPolygonOffset - Setzen eines eines Verschiebungsparameters für die Tiefenberechnung
Tiefenberechnung
glClear - Initialisieren von Puffern
glClearColor - Setzen der Werte für das Löschen des Farbpuffers p im RGBA-Modus
glColorMask - Steuern des Schreibens von Bits in den Farbpuffer
glDrawBuffer - Spezifikation des für das Zeichnen zu verwendenden Farbpuffers
glReadBuffer - Spezifikation des für das Lesen zu verwendenden Farbpuffers
glAlphaFunc - Setzen Setzen von von Referenzwert und und Vergleichsfunktion für für Alphatest
glClearIndex - Setzen der Werte für das Löschen des Farbpuffers im Farbindex-Modus
glIndexMask - Steuern des Schreibens von Bits in den Farbindexpuffer
glClearDepth - Setzen der Werte für das Löschen des Tiefenpuffers
glDepthFunc - Setzen der Vergleichsfunktion für der Tiefentest
glDepthMask - Steuern des Schreibens in den Tiefenpuffer
glClearStencil - Setzen der Werte für das Löschen des Schablonenpuffers
glStencilMask - Steuern Steuern des des Schreibens in den den Schablonenpuffer
Schablonenpuffer
glStencilFunc - Setzen von Referenzwert, Vergleichsfunktion und Maske für Schablonentest
glStencilOp - Setzen der Aktionen für den Schablonentest
glClearAccum - Setzen der Werte für das Löschen des Akkumulatorpuffers
glAccum - Angabe von Operation und Wert zur Steuerung des Akkumulatorpuffers
glScissor - Festlegen von Position und Größe des Schnittrechtecks

100
Selection
Selection: Mechanismus Mechanismus, der der dem Nutzer erlaubt, erlaubt auf Regionen des Bildschirms oder oder auf auf im
Bildschirm dargestellte Objekte zuzugreifen
Zielstellung: g
- Nutzer will Objekte auf dem Bildschirm identifizieren und dann bewegen, verändern oder löschen
- Problem: Zwischen Modell- und Bildschirmobjekten liegen zahlreiche Transformationen
- Anwendung: Nutzerinteraktion, z.B. Pickfunktion
Vorgehensweise:
- Spezifikation eines Arrays zur Aufnahme ausgewählter Sätze
glSelectBuffer(size,*buffer)
- Üb Übergang iin dden Selektionsmodus
S l k i d
glRenderMode(GL_SELECT)
- Initialisierung des Namensstacks:
glInitNames() g t a es() und glPushName(0)
g us a e( )
- Definition eines Sichtvolumens (Modellbereich, Projektionsmatrix, Clipping-Ebenen) für die
Objektauswahl, eingeschlossen durch
glPushMatrix()und glPopMatrix()
- Al Alternierend i d Manipulation M i l i des d Namensstacks N k undd Zeichnung Z i h von Objekten Obj k
glPushName(name), glPopName(), glLoadName(name), draw…
- Beenden des Selektionsmodus
glRenderMode(GL g ( _ RENDER) )
Funktionswert: Anzahl der Treffer (jeweils ein Treffer bis Manipulation des Namensstacks)
- Verarbeiten der im Selektionspuffer bereitgestellten Daten *buffer

101
Picken:
- Sichtvolumen wird alternativ durch einen Viewport-Bereich festgelegt
gluPickMatrix(x,y,width,height,viewport[4])
- x-, y-Werte typischerweise an Mausposition gebunden
Inhalt des Namensstapels:
- ein Name auf Stack, ein Objekt zeichnen: eine Auswahl bei einem getroffenen Objekt
- ein Name auf Stack, mehrere Objekte zeichnen: eine Auswahl bei mehreren getroffenen Objekten
- mehrere Namen auf Stack, ein Objekt zeichnen: mehrfache Auswahl bei einem getroffenen Objekt
Inhalt des Selektionspuffers:
für jeden Treffer: - Anzahl der Namen auf dem Namensstack (0)
(sequentiell) - Minimum (1) und Maximum (2) der z-Werte aller getroffenen Objekte
- Namen (3, ...) der ausgewählten Objekte
GLuint selectBuffer[BUFFER_LENGHT];
GLint hits, viewport[4];
glSelectBuffer(BUFFER_LENGTH,selectBuffer);
glGetIntegerv(GL_VIEWPORT,viewport);
glMatrixMode(GL_PROJECTION);
glPushMatrix(); glLoadIdentity();
glRenderMode(GL_SELECT);
gluPickMatrix(xPos,viewport[3]-yPos,2,2,viewport);
gluPerspective(...); gluLookAt(...); glMatrixMode(GL_MODELVIEW);
glInitNames(); glPushName(0);
glLoadName(1); drawObject(…); glPushName(2); drawObject(…);
glPushName(3); drawObject(…); glPopName(); ...
hits = glRenderMode(GL_RENDER);
if (hits) processHits(hits,selectBuffer);
glMatrixMode(GL_PROJECTION); glPopMatrix();
Programmbeispiel:
glMatrixMode(GL_MODELVIEW);

102
Programmbeispiel
void display(void){
...; drawScene(); selectObjects();}
void drawScene(void){
glMatrixMode(GL_PROJECTION); lM t i M d (GL PROJECTION) glLoadIdentity(); lL dId tit () gluPerspective(...);
l P ti ( )
glMatrixMode(GL_MODELVIEW); glLoadIdentity();
gluLookAt(...); drawTriangle(...); ...}
void selectObjects(void){
j ( ){
GLuint selectBuf[BUFSIZE];
GLint hits;
glSelectBuffer(BUFSIZE,selectBuf);
glRenderMode(GL g ( _ SELECT); );
glInitNames(); glPushName(0);
glPushMatrix();
glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0,5,0,5,0,10);
glMatrixMode(GL g ( _ MODELVIEW); ); glLoadIdentity();
g y();
glLoadName(1); drawTriangle(...);
glLoadName(2); drawTriangle(...); drawTriangle(...);
glPopMatrix(); glFlush();
hits=glRenderMode(GL g ( _ RENDER); );
processHits(hits,selectBuf);}
void processHits(GLint hits, GLunit buffer[]){
GLuint names,*ptr;
ptr=(Gluint t (Gl i t *)buffer;
*)b ff
names=*ptr; ptr+=3;
printf("%d, %d, %d",hits,names,*ptr);
...}

103
Feedback
Feedback: Mechanismus Mechanismus, der der es erlaubt erlaubt, im Programm Ergebnisse des des Rendering-Prozesses
Rendering Prozesses
verfügbar zu machen
Zielstellung: g
- Normal: Anzeige des Rendering-Ergebnisses auf dem Bildschirm
- Ziel: Zugriff auf das erzeugte Bild bzw. die generierten Zeichendaten
- Anwendung: z.B. Druckerausgabe
Vorgehensweise:
- Spezifikation eines Feldes zur Aufnahme der Feedback-Daten
glFeedbackBuffer(size,type,*buffer)
type: GL GL_2D, 2D GL GL_3D, 3D GL GL_3D_COLOR, 3D COLOR GL3D GL3D_COLOR_TEXTURE,
COLOR TEXTURE
GL_4D_COLOR_TEXTURE (x,y,z,w,c,t)
- Übergang in den Feedback-Modus
glRenderMode(GL_FEEDBACK)
- Ausführung von Zeichenbefehlen einschließlich des Setzens von Markern
glPassThrough(token), draw…
- Beenden des Feedback-Modus
glRenderMode(GL glRenderMode(GL_RENDER) RENDER)
- Verarbeiten der im Feedback-Puffer bereitgestellten Daten *buffer
Inhalt des Feedback-Puffers:
fü für jjedes d Primitiv, P i i i Bitmap Bi undd Pixelrechteck Pi l h k wird i d ein i Block Bl k generiert i mit i dem d Objekttyp Obj k
GL_*_TOKEN, *: POINT, LINE, POLYGON, BITMAP, DRAW_PIXEL, PASS_THROUGH, …
gefolgt von Werten, die Eckpunkte und andere Daten beschreiben

104
Funktionsreferenz
glSelectBuffer - Liefert einen Puffer für die Rückgabe von Auswahldaten
glRenderMode - Spezifikation des Rendermodus
glInitNames g - Initialisierung g des Namensstapels p
glPushName - Ablegen eines Namens auf dem Namensstapel
glPopName - Entfernen eines Namens vom Namensstapel
glLoadName - Ersetzen des obersten Elementes des Namensstapels
gluPickMatrix l Pi kM t i - BBeschränkung h ä k des d Zeichenbereiches Z i h b i h auf f einen i Teil T il des d Viewports Vi t
glFeedbackBuffer - Einrichten eines Feedback-Puffers
glPassThrough - Einfügen eines Markers in den Feedback-Puffer
gluErrorString - Bereitstellen eines Fehlercodes
glGetString - Bereitstellen eines Implementationsaspektes von gl
gluGetString - Bereitstellen eines Implementationsaspektes von glu
glFlush - Forcierung der Ausgabe ohne Warten des Programmes
glFinish - Forcierung der Ausgabe mit Warten des Programmes

105
OpenGL Zustandsvariablen
Spezielle Anfragekommandos:
glGet{AttachedShaders,BufferSubData,BufferParameteriv,
BufferPointerv,ClipPlane,ColorTable,ColorTableParameter,
CompressedTexImage CompressedTexImage,ConvolutionFilter,ConvolutionParameter,
ConvolutionFilter ConvolutionParameter
Error,Histogram,HistogramParameter,Light,Map,Material,
MinmaxMinmaxParameter,PixelMap,PolygonStipple,ProgramLogInfo,
Programiv,Queryiv,QueryObjectiv,QueryObjectuiv,SeparableFilter,
ShaderInfoLog,Shaderiv,ShaderSource,String,TexEnv,TexGen,
TexImage,TexLevelParameter,TexParameter,Uniform,VertexAttrib,
VertexAttribPointerv}
glIs{Buffer glIs{Buffer,List,Program,Query,Shader,Texture}
List Program Query Shader Texture}
gluGet{NurbsProperty,String,TessProperty}
gl{PushAttrib,PopAttrib,PushClientAttrib,PopClientAttrib}
GGenerelle ll Abfragekommandos Abf k d für fü ZZustandsvariablen: t d i bl
glGet{Booleanv,Integerv,Floatv,Doublev,Pointerv}
glIsEnabled
KKategorien t i von ca. 380 ZZustandsvariablen: t d i bl
Current Values, Vertex Array, Vertex Buffer Object, Transformation, Coloring, Lighting,
Rasterization, Multisampling, Texturing, Pixel Operations, Framebuffer Control,
Pixel State, , Evaluator State, , Hint State, , Implementation p Dependence, p , Miscellaneous
Zustands-Stacks:
Speicherung aller Zustandsattribute auf Server- und Client-Seite, Tiefe jeweils >= 16

106
8. OpenGL p Shading g Language g g
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Kennenlernen des Prinzips programmierbarer Shader
• Sprachkonstrukte der OpenGL Shading Language
• Integration programmierbarer Shader in OpenGL Programme
Abschnitte:
Shader-Programmierung
- Vorgehensweise
- Graphik-Pipelines
- Verwendung von Shaders
- Erzeugung von Shaders (GLSL)
- Zugriff auf Texture Maps
- Shaderspezifische Mechanismen
- Funktionsreferenz
- Geometrie- und Tesselations-Shader

107
Vorgehensweise
OpenGL Shading Language (GLSL): Programmiersprache, um mit OpenGL auf dem
Grafikprozessor (Grafikkarte) eigene Programme (Shader) auszuführen
Merkmale:
- teilweises Ersetzen der sonst stark limitierten und festen Verarbeitungsvorschriften g
der
Grafikkarte (Grafik-Pipeline)
- als Extension ab Version 1.4, als Standard ab Version 2.0 (2004), derzeit Version 4
- C-ähnliche Programmiersprache
- Spezifika: Vektorendatentypen Vektorendatentypen und und -operationen, operationen Anpassung Anpassung an an OpenGL-Umgebung
OpenGL Umgebung
Shader-Arten:
- Vertex-Shader
- Fragment-Shader
VVerwendung: d
- Effizienzsteigerung
- bessere Hardwareauslastung
- PParallelverarbeitung ll l b it
- Alternative Verarbeitungsstrategien

108
Voraussetzung, Test und Initialisierung:
- Version OpenGL: GL_RENDERER, GL_VERSION
- Version GLSL: GL_SHADING_LANGUAGE_VERSION
- Include GLSL: #include "glew.h" // glew ersetzt gl header file
- Lib Library GLSL GLSL: glew32.lib, l 32 lib glew32.dll
l 32 dll
- Init GLSL: glewInit ()
- Test Extension GLSL: GLEW_ARB_vertex_shader, GLEW_ARB_fragment_shader
- Test Version 2.0 GLSL: glewIsSupported("GL g pp ( _VERSION_2_ 0") )
Programmkontext:
g
#include
#include
void main(int argc, g char **argv) g {
glutInit(&argc, argv); ...
glewInit();
if (glewIsSupported("GL_VERSION_2_0"))
printf("Ready printf("Ready for for OpenGL 2.0\n"); 2 0\n"); else {
printf("OpenGL 2.0 not supported\n");
exit(1); }
setShaders();
glutMainLoop(); }

109
Grafik-Pipelines
Fixed-Function Pipeline: Feste interne Maschinen für Vertex- und Fragment-Shading
mit extern einstellbaren Parametern
Merkmale:
- keine Veränderung der Verarbeitungsreihenfolge
- Beschränkung auf eingebaute Funktionalität
Programmable Shading Pipeline: Steuerung des Vertex- und Fragment-Shading
durch kleine Verarbeitungsprogramme
Merkmale:
- Shader-Programme werden in spezieller Sprache geschrieben
- Einbindung beliebiger Funktionalität
In einem Anwendungsprogramm können beide Verfahren verwendet,
jedoch nicht gleichzeitig aktiviert werden.
Framebuffer
Fragment Processing
Machine
Vertex Processing
Machine
Vertex Data
Pixel Data

110
Vertex-Verarbeitung:
Shader-Struktur:
Projection
Matrix
Modelview
Matrix
Vertex
Coordinates
Normal
Matrix
Normal
Vector
Cli Clipping i
Primitive
Setup
Color Color
Values
TexGen/Texture
Matrix
Texture
Coordinates
Shader
Fog
Coordinates
Feste Operationen nach dem Shader:
- Perspective division
- Viewport mapping
- Primitive assembly assembly
- Frustum and user clipping
- Backface culling
- Two-sided lighting selection
- Polygon-mode processing
- Polygon offset
- Depth range
Variable Operationen in dem Shader:
- Eye-space coordinates
- Primary and secondary colors
- Texture coordinates
- Fog coordinates
- Point size

111
Fragment-Verarbeitung:
Shader-Struktur:
P./S. Colour
Summation
Texture
Mapping
Geometric
Primitive Setup
Per-Pixel Fog
Application
Bitmaps/Pixel
Rectangles
Frame Buffer
Fragment
Tests
Shader
Feste Operationen nach dem Shader:
- Flat or smooth shading (interpolation)
- Pixel coverage computation
- Pixel ownership tests
- Scissor operation
- Stipple-pattern application
- Alpha test
- Depth test
- Stencil test
- Alpha blending
- Logical operations on pixels
- Dithering of color values
- Color masking
Variable Operationen in dem Shader:
- Texel retrieval
- Texture application
- Fog
- Primary and secondary color summation

112
Verwendung von Shaders
Erzeugen, Übersetzen, Verbinden und Ausführen von GLSL Programmen, wobei Compiler und
Linker Bestandteil des OpenGL Drivers sind
Character Character
Strings Strings
glShaderSource
Für jedes Shader Objekt:
- Erzeugung des Shader Objektes
- Übersetzung Übersetzung der Shader Quelle
- Verifikation der Übersetzung
Shader
Shader
Source
Source
glCompileShader
Shader
Shader
Object
Object
j
glAttachShader
glCreateShader
Für das Shader Programm:
- EErzeugung des d Shader Sh d Programms P
- Hinzufügen der Shader Objekte
- Verbindung des Shader Programms
- Verifikation Ve at o des des Verbindens Ve b de s
- Nutzung des Shaders
Shader
Program
glLinkProgram
glCreateProgram
Executable
Shader Program
Vorteil:
Verbindung mehrerer kleinerer Shader Shader
zu einem großen Programm
glUseProgram

113
Beispiel:
GLuint shader, shader program;
GLint compiled, linked;
Const GLchar* shaderSrc[] = {
"void main ()"
"{gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;}" };
shader = glCreateShader (GL_VERTEX_SHADER);
glShaderSource (shader,1,shaderSrc,NULL);
glCompileShader (shader);
glGetShaderiv (shader,GL_COMPILE_STATUS,&compiled);
if (!compiled) {
GLint length;
GLchar log;
glGetShaderiv (shader,GL_INFO_LOG_LENGTH,&length);
log = (GLchar*) malloc(length);
glGetShaderInfoLog (shader (shader,length,&length,log);
length &length log);
fprintf (stderr,"%s",log); }
program = glCreateProgram ();
glAttachShader (program,shader);
glLinkProgram (program);
glGetProgramiv (program, GL_LINK_STATUS,&linked);
if (linked)
glUseProgram (program)
else
fprintf (stderr, "Linker Error");

114

115
Erzeugung von Shaders (GLSL)
Verwendung der OpenGL Shading Language (GLSL) mit allgemeinen und shader-spezifischen
Anforderungen, Datentypen und Sprachkonstrukten
Startpunkt:
- Parameterloses Hauptprogramm mit für C üblicher Syntax und Semantik
Variablendeklaration:
Variablendeklaration:
- Datentypen: float,int,bool
- Definition: an jeder Programmstelle möglich
- Bereich: Gültigkeit g auf Definitionsniveau und allen untergeordneten g Niveaus
- Initialisierung: bei Deklaration möglich
- Konstruktoren: explizite Typkonvertierung erforderlich, z.B. float(1),int(2.0),bool(0)
Aggregat-Typen:
Aggregat Typen:
- Datentypen für 1-, 2-, 3-, 4-dimensionalen Vektoren und Matrizen
float: vec2,vec3,vec4, mat2,mat3,mat4
int: ivec2,ivec3,ivec4
bool: bvec2,bvec3,bvec4
mit entsprechenden expliziten Typkonvertierungsfunktionen, z.B. vec3(0.0,1.0,2.0)
- spezielle Vektoren: Position (x,y,z,w), Farbe (r,g,b,a), Textur (s,t,p,q)
- Komponentenzugriff: über über Index position[0] position[0], über Name color.r color.r
- Strukturen: Zusammenfassungen verschiedenen Typs, z.B. struct Part{float a;vec3 b;};
- Arrays: Felder beliebigen Typs, z.B. bool[8], Part[9]

116
Typmodifikatoren:
- Beeinflussung des Verhaltens von Datentypen
const konstanter Wert
z.B. const float pi=3.14;
attribute attribute Variable in Vertex-Shader verbunden mit mit Vertex-Attributen der der
OpenGL-Anwendung
nur für auf float aufbauenden Datentypen
vor- und nutzerdefinierte globale Variablen
z.B. in Shader: attribute vec3 disp;
in Anwendung: GLfloat dispValue[3];
int index=glGetAttribLocation(program,"disp");
glVertexAttrib3fv(index glVertexAttrib3fv(index,dispValue);
dispValue);
uniform Variable in Vertex- und Fragment-Shader, die von Anwendung übergeben und
für Primitiv im Shader konstant ist
zz.B. B in Shader: uniform float time;
in Anwendung: GLint timeLoc; GLfloat timeValue;
timeLoc=glGetUniformLocation(program,"time");
glUniform1f(timeLoc,timeValue);
varying Variable zur Übergabe von Daten vom Vertex- zum Fragment-Shader
nur für auf float aufbauenden Datentypen
Ausgabe-Variablen im Vertex-Shader als Eingabe-Variablen im Fragment-Shader
Vor- und nutzerdefinierte globale Variablen
z.B. in Vertex-Shader varying float temp;
in Fragment-Shader varying float temp;

117
Anweisungen:
- C- bzw. C++-konforme Operatoren
- Arithmetik: + - * / = == != < > ++ -- () [] . && ^^ || ,
+= *= -= /= ? :
- Alternative: if else
- Iteration: Iteration: for for, while, while do do while
- Steuerung: break, continue, return, discard
- Operatoren sind überladen
Funktionen:
- C- bzw. C++-konforme Definition und Verwendung
- vordefinierte und nutzerdefinierte Funktionen
- returnType functionName([accessModifier] type variable, …)
{functionBody; return returnValue;}
- keine Verwendung von Pointern
- Modifikatoren für für Parameter: Parameter: in, const in, out, inout
Beispiel:
uniform float t;
attribute ib vec4 4 vel; l
const vec4 g = vec4(0.0,-9.8,0.0);
void main () {
vec4 ec pos position t o = vec4(gl ec (g _Vertex); e te );
position += t*vel+t*t*g;
gl_position = gl_ModelViewProjectionMatrix*position;}

118
Vordefinierte Konstanten:
Grenzen: gl g _ Max{Lights,ClipPlanes,TextureUnits,TextureCoords,
{ g , p , , ,
VertexAttribs,DrawBuffers,VertexUniformComponents,
VaryingFloats,VertexTextureImageUnits,
CombinedTestureImageUnits,TextureImageUnits,
FFragmentUniformComponents} tU if C t }
Vordefinierte Uniform Zustandsvariablen:
Transformationsmatrizen: gl_{ModelViewMatrix,ProjectionMatrix,
ModelViewProjectionMatrix,TextureMatrix[n],NormalMatrix
{Inverse,Transpose,InverseTranspose}}
Normalen: gl gl_NormalScale,gl_Normal
NormalScale,gl Normal
Tiefenbereich: gl_DepthRange
Klippebene: gl_ClipPlane
Punktparameter: gl_Point
Material: gl_FrontMaterial,gl_BackMaterial
Li Licht: h gl_LightSource,gl_LightModel,gl_FrontLightModelProduct,
gl_BackLightModelProduct
Textur: gl_TextureEnvColor,gl_EyePlane{S,T,R,Q},gl_ObjectPlane{S,T,R,Q}
Nebel: gl_Fog
>>> generell Datentypen: float, vec4, structure …

119
Vordefinierte Funktionen:
Wi Winkelkonvertierung, k lk i Trigonometrie: T i i radians,degrees,sin,cos,tan,asin,acos,
atan,atan
Transzendenz: pow,exp,log,exp2,log2,sqrt,inversesqrt
Numerik: abs,sign,floor,ceil,fract,mod,min,max,clamp,mix,smoothstep
Vektoren: length,distance,dot,cross,normalize,ftransform,faceforward,
reflect,refract
e ect, e act
Matrizen: matrixCompMult
Vektor-Relationen: lessThan,lessThanEqual,greaterThan,greaterThanEqual,
equal,notEqual,any,all,not
l l ll
Texturen: texture{1D,2D,3D,2DProj,2DProj,3DProj,1DLod,1DProjLod,2DLod,
2DProjLod,3DLod,3DProjLod,Cube,CubeLod},
shadow{1D,2D,1DProj,2DProj,1DLod,2DLod,1DProjLod,2DProjLod}
h d {1D 2D 1DP j 2DP j 1DL d 2DL d 1DP jL d 2DP jL d}
Fragmente: dFdx,dFdy,fwidth
Rauschen: noise{1,2,3,4}
{ , , , }

120
Zugriff auf Texture Maps
Verwendung von Texturen in Vertex- und Fragment-Shadern durch Herstellung einer Verbindung
zwischen der aktiven Textur in der Anwendung und einem deklarierten Sampler im Shader
Charakteristika:
- Übereinstimmung der Dimensionen von Textur und Typ des Samplers
- Unterstützte Sampler-Typen: p yp sampler1D,sampler2D,sampler3D,
p , p , p ,
samplerCube,sampler1DShadow,sampler2DShadow
- Definition und Zugriff:
z.B.: Anwendung: GLint texSampler;
ttexSampler=glGetUniformLocation(program,"tex"); S l lG tU if L ti ( "t ")
glUniform1i(texSampler,2);
Shader: uniform sampler2D tex;
gl g _FragColor=gl g g _ Color*texture2D(tex,gl ( ,g _ TexCoord[0].st); [ ] )
uniform sampler1D coords;
uniform sampler3D volume;
vec3 texCoords=texture1D(coords,gl_TexCoord[0].s);
vec3 3 volumeColor=texture3D(volume,texCoords);
l C l t t 3D( l t C d )
- Aufgabe im Shader: Verwendung von Texturkoordinaten, um Positionen in der Textur zu spezifizieren
und Texturwerte bereitzustellen
- Ermittelte Texturkoordinaten können auf anderen Sampler p übertragen g werden
- vordefinierte Textur-Zugriffsfunktionen

121
Shaderspezifische Mechanismen
Ein- und Ausgabeverhalten von Vertex- und Fragment-Shader
Verwendete Datentypen: bool,float,vec4
Vertex Vertex-Shader: Shader:
- Eingabe: pre-defined attribute variables
gl_Vertex,gl_Normal,gl_Color,gl_SecondaryColor,
gl_TexCoordn,gl_MultiTexCoordn,gl_FogCoord
user-defined vertex attributes
user-defined uniform variables
- Ausgabe: pre-defined special variables
gl gl_Position,gl_PointSize,gl_ClipVertex
Position gl PointSize gl ClipVertex
pre-defined varying variables
gl_FrontColor,gl_BackColor,gl_FrontSecondaryColor,
gl_BackSecondaryColor,gl_TexCoord[n],gl_FogFragCoord,
Fragment-Shader:
- Eingabe: pre-defined varying variables
gl gl_FragCoord,gl_Color,gl_SecondaryColor,
FragCoord,gl Color,gl SecondaryColor,
gl_TexCoord[n],gl_FogFragCoord,gl_FrontFacing
user-defined vertex attributes
user-defined uniform variables
- Ausgabe: pre-defined special variables
gl_FragColor,gl_FragDepth,gl_FragData[n]
discard fragment, multiple output buffer rendering

122
Shader-Beispiele:
Vertex-Shader:
void main(void) {
gl_FrontColor = gl_Color; gl_Position = ftransform(); }
uniform i float time; i
void main(void) {
vec4 v = vec4(gl_Vertex);
v.z v.z = sin(5.0 sin(5.0*v.x v.x + time time*0.01)*0.25;
0.01) 0.25;
gl_Position = gl_ModelViewProjectionMatrix * v; }
Fragment-Shader:
void main(void) {
gl_FragColor = gl_Color; }
varying i vec3 3 li lightDir,normal; h i l uniform if sampler2D l 2 tex;
void main() {
vec3 ct,cf; vec4 texel; float intensity,at,af;
intensity y = max(dot(lightDir,normalize(normal)),0.0);
( ( g , ( )), );
cf = intensity * (gl_FrontMaterial.diffuse).rgb +
gl_FrontMaterial.ambient.rgb;
af = gl_FrontMaterial.diffuse.a;
ttexel l = ttexture2D(tex,gl_TexCoord[0].st); t 2D(t l T C d[0] t)
ct = texel.rgb; at = texel.a;
gl_FragColor = vec4(ct * cf, at * af); }

123
Funktionsreferenz
glCreateShader (type) Erzeugung eines Shader Objektes
glShaderSource (shader,count,string,length) Zuweisung von Quelltext zu Shader Objekt
glCompileShader g C p S ( (shader) ) Übersetzung Ü g von QQuelltext zu SShader OObjekte j
glGetShaderInfoLog (shader,bufSize,length,infoLog) Übersetzungsinformation zu Shader Objekt
glCreateProgram () Erzeugung eines Shader Programms
glAttachShader lAtt hSh d ( (program,shader) h d ) ZZuweisung i Shader Sh d Objekt Obj kt zu Sh Shader d Programm P
glDetachShader (program,shader) Entfernung Shader Objekt zu Shader Programm
glLinkProgram (program) Verbindung eines Shader Programms
glGetProgramInfoLog g g g (p (program,bufSize,length, g , , g , Verbindungsinformation g zu Shader Programm g
infoLog)
glUseProgram (program) Verwendung des Programms als Shader
glDeleteShader lD l t Sh d (shader) ( h d ) Lö Löschen h eines i Shader Sh d Objekts Obj kt
glDeleteProgram (program) Löschen eines Shader Programms
glIsProgram (program) Test auf Shader Programm
glIsShader g (shader) ( ) Test auf Shader Objekt j
glValidateProgram (program) Test Shader Programm in OpenGL Umgebung
glGetShaderiv (shader,pname,params) Shader Objekt Informationen
glGetProgramiv lG tP i (program,pname,params) ( ) Sh Shader d Programm P Informationen
I f ti
glGetAttachedShaders (program,maxCount,count,shaders) Informationen zu zugewiesenen Shaders

124
glGetUniformLocation Index einer Uniform Variable eines Shaders
glUniform Setzen des Wertes einer Uniform Variable
glUniformMatrix Matrixversion der Setzfunktion
glGetAttribLocation Index einer Attribut Variable eines Shaders
glBindAttribLocation Explizite Bindung von Variablen-Indexwerten
glVertexAttrib g
Setzen des Wertes einer Attribut Variable
glVertexAttrib4N Setzen des Wertes mit vorheriger Normaliserung
glVertexAttribPointer Setzen des Wertes in Vertex-Arrays über Pointer
glEnableVertexAttribArray Erlaubnis von Vertex-Arrays
glDisableVertexAttribArray glDisableVertexAttribArray Verbot von Vertex Vertex-Arrays
Arrays

125
Geometrie- und Tesselations-Shader
Geometrie-Shader: - Erzeugung, Löschung und Änderung von primitiven Geometrien
- Punkte, Linien, Dreiecke
- Aufruf nach nach Vertex-Shader
Vertex Shader
- Geometry Shader
Tesselations-Shader: - Bearbeitung und Test von komplexen Geometrien
- Polygone
- Tessellation Control Shaders, Tessellation Evaluation Shaders
� Keine Funktionen der eigentlichen Render-Pipeline
www.lighthouse3d.com/tutorials/glsl-core-tutorial

126
9. Helligkeits- g und
Farbdarstellung
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Kennenlernen der Grundlagen für Helligkeits- und Farbdarstellungen
• Realisierung und Anwendung der Darstellungen in der Computergrafik
Abschnitte:
- Physikalische Grundlagen
- Radiometrie und Fotometrie
- Helligkeitsmetrik
g
- Helligkeitsreduktion
- Farbmetrik
- Farbmodelle
Helligkeit und Farbe als
Basis der Computergrafik

127
Physikalische Grundlagen
Definition: Licht ist der für den Menschen sichtbare Ausschnitt des elektromagnetischen Spektrums
Grundlagen: geben Auskunft darüber, wie das Licht als physikalische Größe
und die vom Menschen empfundenen Farbeindrücke zusammenhängen
Bestandteile: Bestandteile: - Modelle der der Lichtausbreitung in Medien Medien
- Wechselwirkung des Lichtes mit Objektoberflächen
- quantitative Beurteilung charakteristischer Größen
- Wirkung des Lichtes auf optische Sensoren des Menschen
- Wahrnehmung der Reize im neuronalen System des Menschen
Eigenschaften:
* Frequenz: Anzahl der Schwingungen pro Sekunde
* Wellenlänge: räumliche Ausdehnung einer Welle
* Phasenlage: räumliche/zeitliche Verschiebung einer Welle
* Polarisation: räumliche räumliche Ebene einer Welle
* Reflexion: Verhalten an Objektoberflächen
* Refraktion: Verhalten an Objektübergängen
* Beugung: Verhalten Verhalten an an Objektkanten
Objektkanten
* Interferenz: gegenseitige Beeinflussung von Wellen
Natürliches Licht kombiniert verschiedene Eigenschaften g
Superposition: Eigenschaften können einzeln berechnet und überlagert werden
Teilgebiete: Strahlenoptik (makroskopisch), Wellen- und Quantenoptik (mikroskopisch)

128
Radiometrie und Fotometrie
Licht ist eine physikalische Erscheinung, die auf Objekte einer Szene wirkt.
Licht besitzt als Strahlung messbare Energie. Es ist zeitlich und räumlich beschränkt.
(W )
(
(Ws)
( W m
W sr
W m
� �
Q e
)
e
� � )
� �
2
E e
2 � sr�
L e
Radiometrische Größen: Größen:
- Strahlungsenergie (energy): Energie
- Strahlungsleistung (power, flux): Energie pro Zeit, Fluss
�
- Strahlungsstärke (irradiance): Leistung pro Flächeneinheit
- Strahlungsintensität (intensity): Leistung pro Raumwinkel Ie - Strahlungsdichte (radiance): Leistung pro Richtung und Fläche
- Wellenlängen (wavelengths): Spektrum verschiedener Wellenlängen
Licht ist eine psychologische Erscheinung, die auf Sinnes- und Nervenzellen eines Betrachters wirkt.
Licht bewirkt messbare neuronale Effekte. Es ist in der Wirkung auf den Betrachter beschränkt.
Beispiele für Größen:
- MMondlicht: dli ht 0.2 0 2 lx l
- Kerze (1 m Abstand): 1 lx
- Leselicht: 100 lx
- Sonnenlicht: 70000 lx
)
lx
� cd �
,
2
2 � sr�
Photometrische Größen:
- Lichtmenge (quantity) Qv (lms)
- Lichtstrom (flux) (flux) ��
v (lm )
- Lichtstärke (luminosity) Ev ( lm m
- Lichtintensität (intensity) Iv lm sr,
- Leuchtdichte (luminance) Lv lm m
- Kombination von Grundfarben 830
- Diskretisierung: ( R, G,
B)
� �
360

129
Abbildung von radiometrischen zu fotometrischen Größen:
- radiometrisch: X e fotometrisch: X v
Energieverteilung im
- Hellempfindlichkeitsfunktion: V (�)
absorbierten Lichtspektrum:
- Proportionalitätsfaktor:
- Abbildung:
830
�
X
Km
Energie
X v � Km
� X e�
( �)
V ( �)
d�
dichte
Wellen
länge
(nm)
360
Optische p Rezeptoren: p
400 700
- Helligkeitssehen: 120 Mio Stäbchen: Schwarz/Weiß
- Farbsehen: 6 Mio Zapfen: Rot, Grün, Blau
Absorbierter Lichtanteil
0.2
Empfindlichkeitskurven für
Farbdifferenzen, Helligkeit und Farbe:
Wellenlängendifferenz
Absorbierter Lichtanteil
0.4
16
Wellen
länge
(nm) (nm)
WWellen ll
länge
(nm)
Wellen
länge
(nm)
400 500 600 700
400 700
400 700

130
Helligkeitsmetrik
Helligkeitsmetrik: Lehre von den Maßwerten der Lichtintensität.
Lichtintensität ist einziges Attribut für einfarbiges Licht.
Skalare Größe: I ��0,
1�
mit 0: schwarz, 1: weiß, sonst: grau
Helligkeit: Helligkeit: Integral Integral aus aus Produkt Produkt von von Energieverteilung Energieverteilung und und Helligkeitsempfindlichkeitsfunktion
Dynamikbereich
Dynamikbereich,
Intensitätswerte:
- CRT: 200, 400
- Foto: 1000, 1000 700 700
- Zeitung: 10, 200
Auswahl von Intensitätswerten:
- Lichtintensität wird von speziellen p Sinneszellen wahrgenommen g
- entsprechende Darstellung auf Bildschirm erforderlich
- Merkmale: Anzahl der Intensitätswerte n (z.B. 256) 0 � j � 255
. maximale Intensität I n (z.B. 1.0), minimale Intensität I0
(z.B. 0.02)
. Verhältnis benachbarter benachbarter Intensitäts Intensitätswerte erte r �� I In
I n�1
(z.B. ( B 1.01545…) 1 01545 )
- Verteilung der Intensitätswerte logarithmisch (nicht linear)
- Dynamikbereich: In I0
(z.B. 50)
n
- Berechnung g des Wertes für r:
r � I n I 0
- Ermittlung des nächsten Intensitätsindexes: j � round (logr ( I j I0
))
- Ermittlung der zugehörigen Intensität:
j
I j r I0
�
I
- ggf ggf. Ausgleich der Nichtlinearität
Nichtlinearität
über Gamma-Korrektur
(mit Gerätekonstante K
und Korrekturwert � ): )
j
V �
j I j K �

131
Helligkeitsreduktion
Helligkeitsreduktion: Verfahren zur Darstellung einer einer großen großen Anzahl von Helligkeitswerten durch durch
räumliche Integration einer reduzierten Anzahl von Helligkeitswerten (Halftoning, Dithering)
Problem: Reduktion der Helligkeitswerte führt zu Realitätsverlust
Kompromiss: zwischen radiometrischer und räumlicher Auflösung
Zuordnungsverfahren: statisch, dynamisch, deterministisch, stochastisch
Einfache Reduktion: Abbildung von einem Bereich mit m Helligkeitswerten
auf einen kleineren Bereich mit m' Werten bei gleicher räumlicher Auflösung
- Abbildung: I '� round�m'
I m�
Binäres Dithermuster: n x n -Matrix zweiwertiger Pixel
2
- darstellbare Helligkeitswerte: n �1
- Musterformen: Quadrat, Sechseck, Kreis
- Dithermatrix (Schwellwertmatrix):
� �
� �6 8 4
� ��
� �
��
1 0 3
�5
2 7
�
( 3 )
D
2��
1
�
�
��
0
�
�3
�
)
2
(
D
Mehrwertiges g Dithermuster: n x n -Matrix k-wertiger g Pixel
2
- darstellbare Helligkeitswerte: n ( k �1)
�1
0 0 1 0 2 1 2 1 2 2 3 3 3 3
. . .
. . .
0 0 0 0 1 1 1 2 1 2 2 3 3 3
Musterentwurf: - Ordnung nach Helligkeitsstufen
- Vermeidung von Artefakten

132
Schwellwertverfahren mit größerer räumlicher Auflösung:
- Verwendung g von Schwellwerten und Anordnung g in einer binären
Dithermatrix D (n)
- Setzen aller Elemente D (n) i,j der Dithermatrix, die kleiner als die Intensität
S(x,y) des Pixels P(x,y) sind (S(x,y) > D (n) i,j), auf 1
- Setzen Setzen aller anderen anderen Elemente der der Dithermatrix auf auf 0
- Zeichnen der veränderten Dithermatrix anstelle des Pixels P(x,y)
Schwellwertverfahren mit gleicher räumlicher Auflösung:
- Verwenden von Schwellwerten und Anordnung in einer binären
Dithermatrix: D (n)
- Ermittlung der zu einem Pixel P(x,y) gehörenden Position eines
Schwellwertes in der der Dithermatrix: Dithermatrix: i = x mod n , j = y mod n
- Vergleichen von Pixelwert und Schwellwert: S(x,y) > D (n) i,j
- Zeichnen einer 1 bei Pixel P(x,y), wenn Pixelwert größer Schwellwert
- Zeichnen einer 0 sonst
Beispiel für Dithermatrix:
�� 0 2 2��
� �
�3
1�
�
)
2
(
D
Bei homogenen Belegungen liefern beide Verfahren
das gleiche Ergebnis.

133
Streuverfahren:
- Schwellwertmatrix als sich sukzessive auffüllendes, verdichtetes Feld
� dadurch homogenes Aussehen
Clusterverfahren:
- Schwellwertmatrix als von innen nach außen wachsendes periodisches p Feld
� dadurch weniger Rauschen, unterschiedlich große gefärbte Bereiche
Zufallsverfahren:
- Addieren eines Zufallswertes zum Schwellwert
� dadurch Einbringung von Rauschen, Vermeidung von Artefakten
Interpolationsverfahren:
- Interpolation der Übergänge zu benachbarten Matrizen
� dadurch glatte, fließende Übergänge
Fehlerdiffusionsverfahren:
- Ermittlung der Differenz zwischen exaktem und dargestelltem Pixelwert
- Zerlegung der Differenz in 4 Werte und
Addition zu exakten Nachbarwerten
� dadurch Erreichen der exakten Helligkeit eines Bereiches
Sonstige / zusätzliche Verfahren:
Stippling: Start mit initialer Verteilung
Relaxation: Ausgleich der Verteilung

134
Farbmetrik
Farbmetrik: Lehre von von den den Maßbeziehungen der Farben untereinander.
untereinander
Lichtintensitäten können Lichtanteilen verschiedener Wellenlängen zugeordnet werden.
Vektorielle Größe: ( R,
G,
B)
, R,
G,
B ��0,
1�
mit 0: kein Anteil, 1: voller Anteil, sonst: anteilig
Farbe: Integral aus Produkt von Energieverteilung und Farbempfindlichkeitsfunktion
Problem: - keine Emmitoren und Rezeptoren für spektrale Leuchtdichteverteilungen
- mehrere spektrale Leuchtdichteverteilungen erzeugen gleichen Farbeindruck
Fragen: - Strahlungsspektrum an Objektoberfläche
- Farbdarstellung in Bildpunkt des Monitors / Druckers
- Farbwahrnehmung durch Auge und Gehirn
Psychophysische Begriffe:
Perzeption: Colorimetrie:
- Farbton (Hue) - Dominante Wellenlänge
- Sättigung (Saturation) (Saturation) - Wellenlängenreinheit
- Helligkeit (Lightness / Brightness) - Leuchtdichte
Farbmischung:
Additiv:
Green
Subtraktiv:
Y
C
M
Blue
Red

135
Grundlagen der additiven Farbmischung:
Farberkennung im Auge: Tristimulus-Theorie: Tristimulus Theorie: 3 Arten von von Rezeptoren Rezeptoren für für R, G, B
Farbdarstellung auf Monitor: je 256 Intensitätsstufen für R, G, B
1. Graßmannsches Gesetz: 4 Farbvalenzen sind stets linear abhängig
2. Graßmannsches Gesetz: 2 gleiche Farben ergeben mit einer 3. Farbe jeweils wieder gleiche Farben
Folgerung: 3D-Farbraum mit Farbvalenzen als Vektoren C=rR+gG+bB
baryzentrischer Farbraum: r'=r/(r+g+b), g'=g/(r+g+b), b'=b/(r+g+b), r'+g'+b'=1
allein durch positive Werte für r, g, b nicht alle Farbvalenzen erreichbar
PProblem: bl negative i Farbwerte F b (Hinzumischung (Hi i h zu Zielfarbe) Zi lf b )
Spektralwertkurven für R, G, B:
C
Farbraum:
B
R
G
Chromazitätsdiagramm für R, G, B:
G
500
600
C
700
B R
400

136
CIE-Farbsystem:
CIE-Farbsystem: CIE Farbsystem: Farbsystem, das das es es gestattet auf auf der der Basis von von drei drei Grundfarben X, Y, Y, Z alle
Farben des sichtbaren Spektrums darzustellen mit ausschließlich positiven Werten x, y, z
CIE-Farbsystem: Farberkennung im Auge
Folgerung: 3D-Farbraum: C=xX+yY+zZ
baryzentrischer Farbraum: x'=x/(x+y+z), y'=y/(x+y+z), z'=z/(x+y+z), x'+y'+z'=1
Farbraum: CIE CIE-Chromazitätsdiagramm: Chromazitätsdiagramm: CIE CIE-Spektralwertkurven
Spektralwertkurven
z
�x'�
� �
��y
y'��
� ���
��
� ���
x
y
�� z
x
y
Foley u.a.: Computer Graphics, Addison-Wesley, 1996

137
Farbmodelle
Farbmodell: Spezifikation eines eines 3D-Farbkoordinatensystems 3D Farbkoordinatensystems mit mit einem sichtbaren Teilraum, Teilraum
in dem alle Farben in einer speziellen Farbskala liegen
Anwendung: Auswahl, Eingabe, Repräsentation, Speicherung, Austausch, Übertragung
Klassen: hardwareorientiert (Mischung von drei Primärfarben)
wahrnehmungsorientiert (Angabe von Farbton, Sättigung und Helligkeit)
Konvertierung: zwischen Modellen eineindeutig möglich
RGB-Modell
� �
� �
�
�
� �r
� ��
�b g
Struktur: additive Verknüpfung dreier Primärfarben rot, grün, blau
Darstellung: Farbwürfel
Anwendung: Monitor, …
Transformation: nach CIE
� � � ��
�
Bl (001)
� ��
�
� �
��
�
�
�
��
�
�
�
��
�
�
�
�
��
�
� �
��
�x
xr
xg
xb
r
Blue (001)
y yr
yg
yb
g
Magenta (101)
Cyan (011)
�z
zr
zg
zb
b
Whit White (111)
Black (000)
Green (010)
Red (100)
Yellow (110)

138
CMY-Modell
Struktur: subtraktive Verknüpfung dreier Primärfarben cyan, cyan magenta, magenta gelb
� c �
Komplementärfarben zu rot, grün, blau
beginnend mit weißem Licht
�
Darstellung: Farbwürfel wie RGB, jedoch schwarz und weiß vertauscht
��
�
� �
��
� c
m
� y
Anwendung: Drucker, …
Transformation: nach RGB
� �
� �
� �
� �
� �
� �r 1 c
G Y
� ��
� �
��
�
� �
��
� �
�
�
�
� �
�
�
� �
��
g 1 m
�b
1 y
C R
B M
CMYK-Modell
� ��
� ��
�
� ��
c
m
� ��
m
y
� k
Struktur: subtraktive Verknüpfung der drei Primärfarben cyan, magenta, gelb
und schwarz
schwarz ersetzt gleiche Mengen von cyan, magenta und gelb
Darstellung: wie CMY mit zusätzlicher Schwarzangabe
Anwendung: Drucker mit gesondertem Schwarz-Druck
Transformation: von CMY
k:=min(c,m,y)
c:=c-k , m:=m-k , y:=y-k

139
YIQ-Modell
Struktur: bestehend aus Luminanz (Helligkeit y) und
�y �
Chrominanz (Farbart und Farbsättigung i, q)
Darstellung: NTSC-Format
�
Anwendung: Fernsehen in Farbe mit Kompatibilität zu Schwarz/Weiß
��
�
� �
��
�y
i
�q
Transformation: von RGB
� ��
� �
�
r
g
b
587
.
0
299
.
0
� ��
�
0 . 275
�
�
� �
�
� ��
0.
114
0.
321
� �
0.
321
0.
311 �
523
.
0
�
� ��
�
0 . 596
��
0.
212
� ��
� �
�
y
i
q
� ��
� �
�
YUV-Modell
Struktur: bestehend aus Luminanz (Helligkeit y) und
Ch i ( i F bdiff ) � �
� �y
Chrominanz (zwei Farbdifferenzen u, v)
Darstellung: PAL- und SECAM-Format
�
Anwendung: Fernsehen in Farbe mit Kompatibilität zu Schwarz/Weiß
Transformation: nach YIQ (durch Rotation im Farbraum)
��
� �
�
�
�v u
Q ( )
y = y
i = - u sin 33° + v cos 33°
q = u cos 33° + v sin 33°

140
HSV-Modell
� ��
� �
�
� ��
h
�
s
�� v
s
Struktur: Kombination aus Farbton (hue), ( ), Sättigung g g ( (saturation) ) und Helligkeit g ( (value) )
Darstellung: Farbpyramide, -kegel oder -zylinder
HLS-Modell
�
� ��
��
� ��
�h
l
��
s
Struktur: Kombination aus Farbton (hue), Helligkeit (lightness) und Sättigung (saturation)
Darstellung: Farbdoppelpyramide , -kegel oder -zylinder (senkrechte Projektion
des Farbwürfels entlang der Hauptdiagonale von schwarz nach weiß)
Anwendung: Farbeingabe Farbeingabe, Farbauswahl
Transformation: von RGB
sum � (max( r,
g,
b)
� min( r,
g,
b))
h � ( g � b)
/ dif für r � max( r,
g,
b)
diff � (max( ( ( r,
g g,
b ) � min( ( r,
g g,
b ))
h � 2 � ( b � r ) / diff
für f g � max( ( r,
g g,
b )
h � 4 � ( r � g)
/ dif für b � max( r,
g,
b)
l � sum / 2 s � dif / sum für l � 0.
5
s � dif /( 2 � sum)
für l � 0.
5 h : � h � 6 für h � 0;
h : � h*
60
W
B
W
R
G
B
B
Foley u.a.: Computer Graphics, Addison-Wesley, 1996

141
10. Rasterkonvertierung g von
Linien und Flächen
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Kennenlernen grundlegender g g Konzepte p der 2D-Rastergrafik g
• Vorstellung von Verfahren zum Rasterkonvertieren und Füllen von Objekten
Abschnitte:
- Problematik
- Rasterkonvertierung von Linien
- Füllen von Flächen
- Muster, Stil, Dicke
- ZZeichenerzeugung i h
2D-Basisalgorithmen
der Rastergrafik

142
Problematik
Rasterverfahren: Verfahren Verfahren, die die auf unterster unterster Ebene eines Rastergrafiksystems grafische Primitive, Primitive
aus denen eine Szene besteht, in Rasterpunkte (Pixel) zerlegen
VVoraussetzung: t
- Grafikhardware, insbesondere Rechner und Rasterdisplay
- Grafiksoftwaresystem mit Programmierschnittstelle für Pixelgrafikfunktionen
- GGrafisches fi h MModell d ll einer i Szene S zerlegt l t in i grafische fi h Primitive P i iti
- Zugriffsfunktionen für Framebuffer zur Aufnahme der Pixelgrafik
Aufgabe:
- Algorithmen zum Rasterkonvertieren und Füllen
- Generierung der Pixel im Framebuffer
- Einbindung in die Ausgabe-Pipeline
Ausgabe Pipeline
Grafik
Probleme:
- Effizienz
- Lückenbildung
- Treppenbildung
- Stärkedifferenz
- Musterbildung

143
Rasterkonvertierung von Linien
Rasterkonvertierung von Linien: Entwicklung von von Algorithmen zum zum Zeichnen Zeichnen der der Pixel des des Randes Randes
von zweidimensionalen primitiven geometrischen Objekten (Scan Converting)
Zeichnen von Linien:
Inkrementeller Linien-Scan-Algorithmus:
Prinzip: - Berechnung des Anstiegs
- Berechnung des Startpixels
- Erhöhung des Argumentwertes
- Berechnung des Funktionswertes
- Ermittlung g des zum Funktionswert nächsten Pixels
Vorschrift: y � mx � n yi�1
� yi
� m�x
Voraussetzung: m � 1 , sonst Ausnutzung von Symmetrie
Eigenschaft: ineffiziente Gleitkommaarithmetik
Algorithmus:
void Line(int x0,int y0,int x1,int y1,int v){
int x; double dy=y1-y0; double dx=x1-x0;
double m=dy/dx; m dy/dx; double double yy=y0; y0;
for (x=x0; x

144
Mittelpunkt-Linien-Algorithmus: (Bresenham)
Prinzip: - Ermittlung des Startpixels, Initialisierung der Entscheidungsvariable
- IInkrementelle k ll Berechnung B h der d Entscheidungsvariable
E h id i bl
- Entscheidungsvariable gibt an, ob Funktionswert über Mittelpunkt zweier Pixel liegt
- Zeichnung des unteren oder oberen Pixels
Vorschrift: Vorschrift:
y � dy dx x � n
explizite Geradenform
f ( x,
y)
� dy � x � dx � y � n � dx � 0 implizite Geradenform
d
Entscheidungsvariable alt
alt � f ( x p �1,
y p �1/
2)
d
EEntscheidungsvariable h id i bl neu für fü Fall F ll E
neuE � f ( x p � 2,
y p �1/
2)
d
Entscheidungsvariable neu für Fall NE
neuNE � f ( x p � 2,
y p � 3/
2)
d dy dx / 2
Startwert der Entscheidungsvariable (bei (0,0))
Start � �
��
� dy
Inkrement bei bei Wahl Wahl des Pixels E
E � dy
� Inkrement bei Wahl des Pixels NE
NE�
dy � dx
...� 2
Verdopplung aller Werte
Voraussetzung: m �1
, sonst Ausnutzung von Symmetrie
Ei Eigenschaft: h ft effiziente ffi i t Festkommaarithmetik
F tk ith tik
Algorithmus:
NE
E
void MidpointLine(int x0,int y0,int x1,int y1,int v){
int dx=x1 dx=x1-x0; x0; int int dy=y1 dy=y1-y0; y0; int int d=2 d=2*dy-dx; dy dx;
int incrE=2*dy; int incrNE=2*(dy-dx);
int x=x0; int y=y0;
WritePixel(x,y,v);
while (x

145
Rasterkonvertierung von Kreisen:
Einfacher Kreis-Scan-Algorithmus: g
2
Prinzip: - Unterteilung in 8 Oktanten nach Symmetrie, Berechnung des 2. Oktanten
(Effizienz- und Darstellungsprobleme bei weniger Segmenten)
- Initialisierung g des Argumentwertes
g
- Erhöhung des Argumentwertes
- Berechnung des Funktionswertes
- Ermittlung der Koordinaten für 8 Pixel
Vorschrift:
2 2
y � r � x
Alternative: x � r cos� , y � r sin�
Eigenschaft: ineffiziente Gleitkommaarithmetik
Algorithmus: g
r
void Circle(int r,int v){
int x; int y; int x1=r/sqrt(2);
for (x=0;x

146
Mittelpunkt-Kreis-Algorithmus: (Bresenham)
Prinzip: - Berechnung des 2. Oktanten (Rest über Symmetrie)
- EErmittlung ittl des d Startpixels, St t i l Initialisierung I iti li i der d Entscheidungsvariable
E t h id i bl
- Inkrementelle Berechnung der Entscheidungsvariable
- Entscheidungsvariable gibt an, ob Funktionswert über Mittelpunkt zweier Pixel liegt
- Zeichnung g des oberen oder unteren Pixels
Vorschrift:
2 2 2
f ( x,
y)
� x � y � r � 0 implizite Kreisform
d
Entscheidungsvariable alt
alt � f ( x p �1,
y p �1/
2)
d f ( 2 1/
2)
EEntscheidungsvariable t h id i bl neu für fü Fall F ll EE
neuE � f ( x p � 2,
y p �1/
2)
dneuSE
� f ( x p � 2,
y p � 3/
2)
Entscheidungsvariable neu für Fall SE
d r
Startwert der Entscheidungsvariable (bei (0,r))
Start � 5 / 4 �
� � 2 � 3
Inkrement bei Wahl von Pixels E
E x p
� SE�
2( x p � y p ) � 5
Inkrement bei Wahl von Pixel SE
…-1/4 Subtraktion vom Startwert
Ei Eigenschaft: h ft effiziente ffi i t Festkommaarithmetik
F tk ith tik
Algorithmus:
void MidpointCircle(int r,int v){
int x=0; x 0; int yy=r; r; int int dd=1-r; 1 r;
CirclePoints(x,y,v);
while (y>x){
if (d

147
Mittelpunkt-Kreis-Algorithmus mit Differenzen 2. Ordnung:
Prinzip: - direkt berechnete Deltafunktionen für Entscheidungsvariable sind lineare Gleichungen
- ddamit it inkrementelle i k t ll Berechnung B h auchh der d Deltafunktionen D lt f kti möglich ö li h
Vorschrift:
( x
alter Punkt
p, y p )
( x p �1
, y p )
neuer Punkt bei E
( x p �1, y p �1)
neuer Punkt bei SE
� Enew � � Eold � 2
Differenz im Fall E (dx=1, dy=0)
� SEnew � � SEold � 2
Differenz im Fall E (dx=1, dy=0)
��
� 2
Diff Differenz iim FFall ll SE (dx=1, (d 1 ddy=-1) 1)
Enew � � Eold � 2
� SEnew � � SEold � 4
Differenz im Fall SE (dx=1, dy=-1)
Eigenschaft: hoch effiziente Festkommaarithmetik
Al Algorithmus: ith
void MidpointCircleSecondOrder(int r,int v){
int x=0; int y=r; int d=1-r; int dE=3; int dSE=-2*r+5;
CirclePoints(x,y,v); ( ,y, );
while (y>x){
if (d

148
Füllen von Flächen
Füllen von Flächen: Entwicklung elementarer elementarer Algorithmen zum zum Belegen der der inneren inneren Pixel von von
primitiven zweidimensionalen Objekten (Filling)
Anwendung: Füllung beliebiger Objekte, Schraffur, dicke Linien, Zeichen, Schattierung, Rendering
Aufgaben: Ermittlung der Pixel, Bestimmung der Farbe
Klassen: pixelorientiert, kantenorientiert
Pixelorientiertes Füllen: Füllen:
Flutungs-Algorithmus:
Prinzip: - Start mit Pixel im Innern des Objektes
- Färben des Pixels
- Ermittlung von benachbarten Pixeln
- Ausschluss der Pixel, die bereits gefärbt sind oder zum Rand gehören
- Rekursiver Aufruf Aufruf mit mit neuen Pixeln Pixeln
Voraussetzung: Objekt mit geschlossenem Rand bekannter Farbe
Eigenschaft: allgemeingültiges Verfahren, ineffiziente Rekursion, Auslaufen
Algorithmus:
void FloodFill(int x,int y,int vr,int vf){
if (ReadPixel(x,y)!=vr && ReadPixel(x,y)!=vf){
WritePixel(x,y,vf);
FloodFill(x FloodFill(x,y-1,vr,vf); y 1 vr vf); FloodFill(x FloodFill(x,y+1,vr,vf);
y+1 vr vf);
FloodFill(x-1,y,vr,vf); FloodFill(x+1,y,vr,vf);}}

149
Scanlinienorientiertes Füllen:
Rechteck-Füll-Algorithmus: g
Prinzip: - Verwendung vertikal angeordneter horizontaler Scanlinien
- Bestimmung der Parameter der Scanlinien durch Extremwerte des Rechtecks
- Durchlaufen der Scanlinien und Färben der Pixel
Voraussetzung: achsenparallele Lage
Algorithmus:
void RectangleFill(int x0,int x1,int y0,int y1,int v){
int x; int y;
for (y=y0;y

150
Polygon-Füll-Algorithmus:
Prinzip: p - Verwendung g vertikal angeordneter g horizontaler Scanlinien
- Berechnung der Schnittpunkte der Scanlinien mit Polygonkanten
- aufsteigende Ordnung der Schnittpunkte
- Bestimmung der inneren Bereiche über Ungeradzahligkeitsregel
- Füllen der der inneren inneren Bereiche Bereiche auf auf der der Scanlinie
Vorschrift: ( xn, yn
) n � 0 Schnittpunkte zwischen Polygonkanten und Scanlinie
x2n�1 � x � x2n
Ungeradzahligkeitsregel
ET ( y , , , 1 ) Kantentabelle geordnet nach ymin
min min, y max max,
x min min,
m)
aktuelle Kantentabelle geordnet nach x (Schnittpunkte mit Scanlinie)
y y
AET y , x,
1 m)
( max
ymin
ET / AET:
Algorithmus:
xmin
Setze y auf kleinsten in ET vorkommenden Wert;
Lösche AET;
Wiederhole bis AET und ET leer {
Hole aus ET alle Kanten in AET, für die ymin=y;
Entferne aus AET alle Kanten für die y=ymax;
Sortiere AET nach x;
Fülle Pixel der Scanlinie nach Paaren in AET
(gemäß Ungeradzahligkeitsregel)
Erhöhe y um 1;
Aktualisiere x-Werte in AET gemäß 1/m; }

151
Nachteile:
- Horizontale Kanten (müssen gesondert behandelt werden)
- Schmale Polygone (auftretende Lücken müssen geschlossen werden)
- nichtganzzahlige Endpunkte (Ausgleich von Rundungsfehlern)
- doppelte End- End und Schnittpunkte (dürfen nur nur einmal einmal gezeichnet gezeichnet werden) werden)
- Berührung und Überlappung von Polygonen (Behandlung der Randbereiche)
Vorteile:
- Bereichskohärenz (Bereich ändert sich nur geringfügig zur nächsten Scanlinie)
- Kantenkohärenz (Kanten treten meist auch bei nächster Scanlinie wieder auf
� Kombination mit Algorithmus zur Rasterkonvertierung von Linien

152
Muster, Stil, Dicke
Muster Muster, Stil, Stil Dicke: Dicke: spezielle Füllaufgaben, Füllaufgaben die gesonderte gesonderte Lösungen Lösungen erfordern, erfordern jedoch im im
Zusammenhang mit Zeichen- und Füllalgorithmen behandelt werden können
Muster: Muster:
- Darstellung als Bitmap mit Werten 1, 0
- Verankerung: Musterpunkt an Polygonpunkt oder Fensterpunkt
- Indexierung: WritePixel(x,y,(b[x%m][y%n]));
- VVerfahren: f h SScanlinien li i (fensterorientiert), (f i i ) Rechtecke R h k (polygonorientiert)
( l i i )
Stil:
- Darstellung als Bitvektor Bitvektor mit Werten 0, 0, 1
- Verankerung: Stilpunkt an Linienpunkt
- Indexierung: WritePixel(x,y,(b[i(x,y)%m]));
- Verfahren: Scanlinien, Liniensegmente
Dicke:
- Verwendung eines dicken Pinsels
- Fragen: g Pinselform, , Pinselorientierung, g, Linienenden, , Polygonecken yg
- Verfahren: - spalten- oder zeilenweise Wiederholung
- Wiederholung in Normalenrichtung
- quadratischer oder kreisförmiger Bereich
- Flä Flächenfüllung h füll zwischen i h zwei i Linien
Li i

153
Zeichenerzeugung
Zeichenerzeugung: Darstellung von von Zeichen Zeichen (Buchstaben, (Buchstaben Ziffern, Ziffern Sonderzeichen) als Bitmap oder oder
polygonal begrenzten gefüllten Bereich
Allgemeines:
Allgemeines:
- Erzeugung eines Fonts mit je einer Repräsentation für alle Zeichen
- Bereitstellen von Operationen zur Veränderung aller Zeichen eines Fonts
Bi Bitmap-Darstellung:
D ll
- explizite Darstellung
- Aufbau durch Einscannen oder Zeichnen vergrößerter Darstellungen einzelner Zeichen
- Manipulation, z. B. bold, bold, italic
- Bereitstellung von Zusatzinformationen, z.B. Höhe, Breite, Abstände
- Verwendung durch zeilenweises Scannen oder Übertragung des rechteckigen Bereiches
PPolygon-Darstellung: l D t ll
- implizite Darstellung
- Polygonale oder polynomiale Darstellung einer Folge von Kurvensegmenten (Splines)
- Manipulation, p , z.B. bold, , italic, , scale, , rotate
- Bereitstellung von Zusatzinformationen
- Verwendung durch Konturzeichnen und Füllen

154
11. Klippen pp und Glätten
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Rastergrafikverfahren zur Ergänzung der Basisverfahren
• Effiziente Algorithmen zur Vermeidung negativer Effekte
Abschnitte:
- Problematik
- Klippen von Objekten
- Glätten von Kanten
- Fortgeschrittene Rastergrafikalgorithmen
Rastergrafikalgorithmen
2D-Aufbaualgorithmen
der Rastergrafik

155
Problematik
Klippen und Glätten: Verfahren der Rastergrafik, die in Kombination mit Basisalgorithmen
geometrische Primitive in Abhängigkeit von Größe und Auflösung des Anzeigebereiches bearbeiten
Voraussetzung:
- Algorithmen g zum Rasterkonvertieren und Füllen grafischer g Primitive
- Informationen über Größe und Auflösung des Anzeigebereiches
Aufgabe: g
- Algorithmen zum Klippen und Glätten
- Einbindung in die Basisrasteralgorithmen
Probleme:
- Effizienz
- Speicherbereichsüberlauf
- Bereichsbeeinflussung
- Bildumlauf
- Visuelle Effekte

156
Klippen von Objekten
Klippen: Verfahren zum Entfernen aller Teile geometrischer Primitive, die außerhalb eines
achsenparallelen rechteckigen Bereiches liegen (Clipping)
Klippen Klippen von von Linien:
Voraussetzung:
- Menge von darzustellenden geraden Linien
- rechteckiger achsenparalleler achsenparalleler Bereich (Klipp-Region)
(Klipp-Region)
- gegebenenfalls Drehung von Primitiven und Bereich
Analysieren:
- Bestimmung von Schnittpunkten und damit Intervallen
- y � mx � n , x � x � x � x � y � y � y � y
max
min
max
min
Beschneiden:
- Durchführen zusätzlicher Tests bei Rasterkonvertierung (Scissoring)
- xmin � x � x , y � y � y
max
min
max
Kopieren:
- Zeichnen in ein großes virtuelles Fenster
- Verwendung eines Fensterausschnittes zur Anzeige
Parametergleichungen:
- Verwendung von Parametergleichungen mit Parameterintervall
- x
� xmin
� t(
xmax
� xmin
) , y � ymin
� t(
ymax
� ymin
) , 0 � t �1

157
Cohen-Sutherland Algorithmus:
Bereiche um Klipp-Region durch Bit-Codes C verschlüsselt
li links: k x � xmin
0001
rechts: x � xmax
0010
unten: y � y 0100
min
oben: y � y max 1000
1001 1000 1010
Algorithmus:
0001 0000 0010
0101 0100 0110
for (jede Strecke){
Zuordnung von von Bit-Codes Bit Codes zu zu Endpunkten pp, q ;
Test1: if ((C(p)vC(q))==0) Strecke ganz sichtbar;
Test2: if ((C(p)^C(q))!=0) Strecke ganz unsichtbar;
Ermittle Menge M der Strecken für die Test1 und Test2
nicht erfüllt;}
while (Menge M dieser Strecken nicht leer){
Wähle eine dieser Strecken aus;
Wähle Endpunkt dieser Strecke mit C(p)!=0;
Wähle Bit dieses Endpunktes Endpunktes mit mit Wert 1; 1;
Berechne Schnittpunkt der Strecke mit zu diesem
Bit gehöriger Gerade;
Ermittle neuen Bit-Code dieses Schnittpunktes;
Verwende diesen Schnittpunkt Schnittpunkt als neuen Endpunkt
der Strecke;
Führe Test1 und Test2 mit neuer Strecke aus;
Füge die Strecke zu M hinzu, falls Test1 und
Test2 nicht nicht erfüllt;}
erfüllt;}

158
Cyrus-Beck Algorithmus:
- Berechnung von Schnittpunkten ti zwischen Strecken und Kanten
- Parameterdarstellung der Strecke: P ( t)
� P0
� ( P1
� P0
) t
- Skalarprodukt für Schnittpunktbestimmung: N
: Rand,
i �( P(
t)
� PEi
) � 0
0: außen
Ni
�(
P0
� PEi
)
- Bestimmung Bestimmung von von t:
t �
D � P � P
Ni
D
- Zuordnung einer Halbebene zu jeder Kante
- Berechnung: Ni*D=0: Winkel = 0°, Strecke – Kante parallel
N D>0 Wi k l 0: Winkel

159
Klippen von Kreisen und Ellipsen:
- Klipp-Test mit Bounding Boxes für Kreis/Ellipse, ihre Quadranten und Oktanten
- gegebenenfalls b f ll gleichzeitige l i h i i analytische l i h Berechnung h der d Schnittpunkte h i k für f Oktanten k
- Rasterkonvertierung mit ermittelten Start- und Endpunkten
Klippen pp von Polygonen: yg
Sutherland-Hodgman Algorithmus:
Aufgabe: Klippen eines beliebigen Polygons an einem konvexen Klipp-Polygon
Anwendbarkeit: 2D 2D Rechtecke, Rechtecke …, 3D Polyeder als als Klipp Klipp-Polygone Polygone
Voraussetzung: ungeklipptes Polygon als Punktfolge
Resultat: geklipptes Polygon als Punktfolge
Algorithmus:
- Verwaltung einer aktuellen Menge von Eckpunkten des Polygons
- schrittweises Klippen des Polygons an allen Kanten des Klipp-Polygons
- in jedem j Schritt Durchlaufen aller Punkte des Polygons yg
- für jeden Punkt Untersuchung der folgenden
Polygonkante in Beziehung zu Klippkante
- gegebenenfalls Klippen der Polygonkante
- gegebenenfalls g g Hinzufügen g einer Polygonkante
yg
Fallunterscheidung:
1 Polygonkante sp liegt innerhalb: p hinzufügen
2 Polygonkante sp schneidet von innen nach außen
bei Schnittpunkt p i: i hinzufügen g
3 Polygonkante sp liegt außerhalb: kein Aktion
4 Polygonkante sp schneidet von außen nach innen
bei Schnittpunkt i: i und p hinzufügen

160
Klippen am 3D Sichtvolumen:
* Generelles Vorgehen:
- Algorithmen lassen sich vom 2D Raum analog auf den 3D Raum übertragen
- Klipp-Volumen ist ein Quader
- praktisch praktisch ist meist ein Klippen am am kanonischen kanonischen Volumen Volumen ausreichend ausreichend
- Anwendung für parallele und perspektivische Projektion
* Cohen-Sutherland Algorithmus:
- Verwendung eines 6-stelligen Bit-Codes (parallel / perspektivisch):
oben: 100000 y>1 y>-z
unten: 010000 y-z x> z
links: 000100 x

161
Glätten von Kanten
Glätten: Ausgleich von von Sprüngen Sprüngen in in der Darstellung von von Kanten, Kanten die sich durch durch die Verwendung von von
Rasterungen ergeben (Antialiasing)
Ansätze Ansätze aus grafischer Sicht:
Signaltheorie:
- Sampling: Auswahl einer endlichen Menge von Werten eines Signals
- Reconstruction: Regenerierung Regenerierung des Originalsignals aus aus seinen Samples
- Re-/Supersampling: Erstellung eines Samples aus mehreren Samples
- Aliasing: Auftreten niederfrequenter Signale bei der Darstellung hochfrequenter Signale
- Rasterung: Scharfe Übergänge zwischen den Pixeln wegen in Samples nicht enthaltenen
hochfrequenten Komponenten des Originalsignals
Signal Signal
Sampling Reconstruction
Sample Sample
Re-/Super-
sampling
Vorfilterung:
- darzustellendes Objekt ist vollständig bekannt
- Pixelwert wird durch Integration über zugehöriger Fläche berechnet
- Filterung vor dem Sampling
- analytisches Verfahren
Nachfilterung:
- darzustellendes Objekt ist nur an bestimmten Punkten bekannt
- Pixelwert wird aus mehreren korrespondierenden
Samples berechnet berechnet
- Filterung nach dem Sampling (Re-/Supersampling)
- synthetisches Verfahren

162
Vorfilterungsverfahren:
Flächensampling: p g
Aufgabe: Glätten von Linien während der Rasterkonvertierung
Prinzip: Ausgleich fehlender räumlicher Auflösung durch radiometrische Auflösung
Voraussetzung: g Rasterpunkte p werden als quadratische q Flächen betrachtet
Annahme: Linien haben bei der Darstellung stets eine Dicke, Darstellung als Rechteck
Folgerung: Linie liefert Intensitätsbeitrag zu allen Flächen, die sie schneidet
Intensitätswert berechnet sich aus Anteil der überdeckten Pixelfläche
Ergebnis: gradueller, gradueller weicher weicher Übergang Übergang zwischen zwischen Linie und und Umgebung Umgebung
Nachteil: schlechtere Unterscheidung zu originalen Grauwertlinien
Algorithmus:
- Integration der Signalwerte über ein Quadrat
zentriert im Rasterpunkt
- Division des Integralwertes durch die
Quadratfläche
- Verwendung des Quotienten als Intensitätswert
des Pixels
Integration:
- Zerlegung jedes jedes Pixels Pixels (Quadrates) in Subpixel
(Teilquadrate)
- Zählen der überlappten Subpixel (Teilquadrate)

163
Ungewichtetes Flächensampling:
Merkmale:
- IIntensität t ität sinkt i kt nicht i ht mit it Ab Abstand t d ddes Pi Pixelzentrums l t von der d Linie Li i
- Nicht schneidende Linien beeinflussen Pixelintensität nicht
- Gleiche Schnittflächen bewirken gleiche Pixelintensitäten
Realisierung
- Quadrat als Pixelfläche
- konstante Gewichtsfunktion, Quader-Filter I=cImax
Vorteile:
- llokale k l Definition D fi iti
- hohe Effizienz
Gewichtetes Flächensampling:
Merkmale:
- Intensität sinkt mit Abstand des Pixelzentrums von der Linie
- Nicht schneidende Linien beeinflussen Pixelintensität nicht
- Gleiche Schnittflächen näher des Pixelzentrums bewirken
größere Pixelintensitäten
Realisierung:
- Kreis größer als als Pixelfläche Pixelfläche
- variable Gewichtsfunktion, Kegel-Filter I=W(x,y)Imax
Vorteile:
- Überlappung der Kreise vermeidet Lücken
- Rotationssymmetrie
- lineare radiale Funktion
- Unabhängigkeit gegenüber geometrischen Transformationen

164
Gupta-Sproull-Algorithmus:
Aufgabe: Integration des Kegel-Filters in Rasterkonvertierungsalgorithmus
Filt Filter: vorberechnete b h t Werte W t in i Tabelle: T b ll Filt Filter(D,t) (D t)
Liniendicke: Konstante t
vdx
Abstand: zwischen Pixel- und Linienmittelpunkt D � v cos�
�
2 2
Nenner: Konstante
dx � dy
Zähler: inkrementelle Berechnung d � F(
M ) � F(
x p �1,
y p �1
2)
für E: d � dx � 2vdx � F(
x p �1,
y p )
für NE: d � dx � 2vdx � F(
x p �1,
y p �1)
Algorithmus:
void AntialiasedLineMidpoint(int x0,int y0,int x1,int y1){
int dx=x1-x0; int dy=y1-y0; int d=2*dy-dx;
int incrE=2*dy; int incrNE=2*(dy-dx); int two_v_dx=0;
double invDenom=1.0/(2.0*sqrt(dx*dx+dy*dy));
double two_dx_invDenom=2.0*dx*invDenom;
int x=x0; int y=y0;
IntensifyPixel(x,y,0);
IntensifyPixel(x,y+1,two_dx_invDenom);
IntensifyPixel(x,y-1,two_dx_invDenom);
while(x

165
Nachfilterungsverfahren:
Reines Punktsampling: p g
- Pixelintensität ergibt sich nur aus Wert des Samples an der Stelle P(x,y)
- Keine Glättung möglich, Lücken entstehen
- Verwendung eines festen regulären Gitters
Statisches Supersampling:
- Kombination mehrerer Samples und Kombination deren Werte
- Festes reguläres g Gitter
- Verwendung von 5, 9 oder mehr Werten der räumlichen Umgebung
- Hoher Samplingrate sind Grenzen durch Effizienz gesetzt
Adaptives Supersampling:
Supersampling:
- Variation der Samplingrate über das Bild
- Anpassung der Rate an den konkreten Bildinhalt
- Unterteilung, wenn Differenz der Samplewerte Schranke überschreitet
- Erhöhung der Rate an Objektkanten, Erniedrigung im Objektinnern
Stochastisches Supersampling:
- Positionierung der der Samples Samples an stochastisch bestimmten bestimmten Positionen
- Verwendung von Verteilungsfunktionen (Normal, Poisson)
- Erzeugung von Rauschen und künstlichen Mustern
� Kombination der Verfahren möglich und sinnvoll

166
Fortgeschrittene Rastergrafikalgorithmen
Rasterkonvertierung:
- Allgemeine Kegelschnitte (Kreis, Ellipse, Parabel, Hyperbel mit Transformationen)
- Dicke Primitive (Linien, Polygone mit End- und Eckpunktbehandlung)
- Berücksichtigung von Linienattributen
Füllen:
- Rekursives Füllen mit erweiterter Entscheidungslogik (Definition von Innerem und Rand)
- Soft-Fill (Objekte mit unscharfen Kanten)
Klippen:
- Nicholl-Lee-Nicholl (Linie an Rechteck mit erweiterter Fallauswahl)
- Liang-Barsky (Polygon an Rechteck mit Bestimmung von Kanten in Eckregionen)
- Weiler (Polygon an Polygon mit Bestimmung gemeinsamer Regionen)
Glätten:
- Kreisglättung (Verwendung konzentrischer Kreise statt Halbebenen)
- Glättung von quadratischen und kubischen Kurven (Berechnung von horizontalen, vertikalen oder
diagonalen Kurvenabständen)
- Glättung allgemeiner Kurven Kurven (Darstellung (Darstellung als Polylinie oder oder Pinsel mit geglättetem geglättetem Muster)
- Glättung von Linienenden (Berücksichtigung des Abstandes von mehreren Kanten)
Text:
- Kombination aus Masterobjekt Masterobjekt und Samplegitter Samplegitter und Filterfunktion
Filterfunktion
- Vorberechnung und Speicherung aller möglicher Erscheinungsformen eines Zeichens

167
12. Sichtbarkeitsbestimmungg
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Kennenlernen von Verfahren zur Bestimmung sichtbarer Flächen
• Effiziente Algorithmen und deren Anwendung
Abschnitte:
- Sichtbarkeitsproblematik
- Optimierungstechniken
- Sichtbarkeitsbestimmungsalgorithmen
Verfahren zur Bestimmung
sichtbarer Flächen

168
Sichtbarkeitsproblematik
Bestimmung Bestimmung, welche Linien und und Flächen von von Objekten einer einer Szene Szene von von einem Betrachterstandpunkt aus aus
nicht durch andere Objekte verdeckt werden, so dass eine ausschließliche Darstellung dieser möglich ist
(visible-line/surface determination, hidden-line/surface elimination)
Problemdefinition:
- gegeben: Menge M von n Objekten o mit Form und Lage, Augpunkt a mit Position
- gesucht: gesucht: Punkt k der Oberfläche f des Objektes Objektes o aus der Menge M, der der vom
Augpunkt a sichtbar ist
- Objekte: Menge von Flächen, Strecken oder Punkten
Kl Klassen von Al Algorithmen: ith
* Bildraum-Algorithmen:
- Bestimme für jedes Pixel p das Objekt, das auf einem Strahl dem Betrachter am nächsten liegt
- AAufwand: f d np, einfache i f h Schritte, S h itt Rastergenauigkeit, R t i k it leicht l i ht parallelisierbar ll li i b
- Anwendung: gerätespezifische Darstellung, Rasterdisplay, Drucker
* Objektraum-Algorithmen:
- Bestimme für jedes j Objekt j die Teile, , deren Sicht nicht durch andere Teile von Objekten j verdeckt wird
- Aufwand: n2 , komplexe Schritte, analytische Genauigkeit, schwer parallelisierbar
- Anwendung: geräteunabhängige Darstellung, Vektordisplay, Plotter
* Linien-Algorithmen:
- Bestimmung einer einer Liste von von Liniensegmenten
Liniensegmenten
* Flächen-Algorithmen:
- Bestimmung einer Matrix von Pixelwerten

169
Optimierungstechniken
Techniken der Sichtbarkeitsbestimmung Sichtbarkeitsbestimmung, die zur zur Vereinfachung Vereinfachung der der Berechnungen Berechnungen oder oder
Reduzierung der Objekte führen und damit eine effiziente Algorithmierung ermöglichen
Kostenintensive Operationen: - Bestimmung Schnittpunkt Projektionsstrahl - Objektfläche
- Bestimmung Schnittpunkt Objekt - Objekt
Kohärenz:
- Grad der Ähnlichkeit zwischen Teilen einer Umgebung oder deren Projektion
- Typischerweise Typischerweise existieren Zusammenhänge Zusammenhänge zwischen Nachbarschaft Nachbarschaft in einer Dimension,
Nachbarschaft in anderer Dimension oder Erscheinungsbild
- Arten: Objekt-, Flächen-, Kanten-, Rasterlinien-, Bereichs-, Tiefen-, Framekohärenz
Perspektivtransformation:
e spe t vt a s o at o :
- Sichtbarkeitsbestimmung im 3D-Raum nach Normalisierung und vor Projektion in 2D-Ebene
- Test auf Verdeckung der Punkte P1=(x1,y1,z1) , P2=(x2,y2,z2) bezüglich Projektionszentrum P=(x,y,0)
Liegen die Punkte auf gleichem Projektionsstrahl und welcher Punkt liegt näher zum Betrachter?
PParallelprojektion: ll l j kti x1=x2 , y1=y2 , z1

170
Hüllenbereiche:
- 2D- oder 3D-Bereiche ermöglichen einfachere Berechnungen und Vorentscheidungen
- Bounding g Box, , Bounding g Volume, , Extent (Rechteck, ( , Q Quader, , Kreis, , Kugel, g , andere Geometrie) )
- einfachste Form: Minimum und Maximum jeder Dimension
- Kostenfunktion: T=bB+oO (Anzahl und Kosten für Bereich und Objekt)
- Ziel: Optimum durch Form der Bereiche
Rückseitenentfernung:
- Entfernung von Flächen, die prinzipiell nicht sichtbar sein können (Backface Culling)
- Beispiele: Innenseiten von Körperoberflächen, dem Betrachter abgewandte Seiten
- EErmittlung: ittl - VVorder- d undd Rü Rückseite k it per Definition D fi iti
- positives Skalarprodukt zwischen Normale und Blickrichtung
Raumunterteilung:
- UUnterteilung t t il des d Raumes R in i Teilräume T il ä unterschiedlicher t hi dli h Größe G öß (Spatial (S ti l Partitioning)
P titi i )
- feste oder adaptive Raumgrößen (z.B. Quadtree, Octree, BSP-tree)
- Zuordnung der Objekte zu Teilräumen
- Suche und Berechnungen g in Teilräumen
Hierarchisierung:
- Unterteilung von Objekten in Bestandteile gemäß räumlicher Beziehungen

171
Sichtbarkeitsbestimmungsalgorithmen
Algorithmen Algorithmen, die in effizienter effizienter Weise Objekte Objekte einer einer Szene Szene bestimmen, bestimmen die von von einem einem Betrachterstandpunkt
aus sichtbar sind; Unterscheidung nach Art der Objekte und angewendetem Verfahren
Algorithmen g zur Bestimmung g sichtbarer Linien:
Objektraum-Linien-Algorithmen
Roberts-Algorithmus:
- Voraussetzung: Strecken als Kanten Kanten konvexer konvexer Polyeder Polyeder
Bestimme Rückseiten der Polyeder;
Entferne Kanten, die Schnittlinien zweier Rückseiten sind;
Schließe Verdeckungen g durch Polyeder y durch Hüllenvergleich g aus;
Vergleiche Kanten auf Verdeckung durch Polyeder;
Entferne komplett verdeckte Kanten, Stutze teilweise verdeckte Kanten;
Setze Algorithmus mit restlicher bzw. neuer Kantenmenge fort;
AAppel-Algorithmus: l Al i h
- Voraussetzung: Strecken als Kanten durchdringungsfreier Polygone
- quantitative Unsichtbarkeit eines Punktes: Anzahl der verdeckenden Polygonvorderseiten
- Konturkante: gemeinsame gemeinsame Kante zwischen Vorder Vorder- und Rückseite einzelner oder oder verbundener verbundener Polygone
Bestimme die Unsichtbarkeit für Eckpunkt einer Kante;
Bestimme Unsichtbarkeit für Segmente entlang der Kante:
Erhöhung bei Passieren einer Konturkante vor Verdeckung;
Erniedrigung bei Passieren einer Konturkante nach Verdeckung;
Solang unverarbeitete Kanten: Beginne Algorithmus von vorn;
Segmente mit Unsichtbarkeit 0 werden gezeichnet;

172
Algorithmen zur Bestimmung des Tiefenpuffers
Bildraum-Flächen-Algorithmen g
z-Puffer-Algorithmus (Catmull):
- Voraussetzung: Polygone oder andere Objekte
- Verfahren: Zeichne Pixel, , wenn dessen Tiefe ggeringer g als bisherige g Tiefe
- Datenstrukturen: Bildspeicher und Tiefenspeicher als 2D-Pixel-Matrizen (frame buffer, z-buffer)
void zBuffer(void) {int x,y;
for(y=0;y

173
Algorithmen mit Prioritätenlisten
kombinierte Objekt-/Bildraum-Flächen-Algorithmen
Datenstruktur: Liste von von Objekten Objekten geordnet geordnet nach nach Tiefeninformationen
Maler-Algorithmus:
- Voraussetzung: in Tiefe separierbare Polygone
- Verfahren: Verfahren: Zeichnen Zeichnen von Objekten gemäß gemäß Betrachterabstand
Sortiere alle Polygone nach ihren kleinsten z-Koordinaten;
Rasterkonvertierung aller Polygone in aufsteigender Reihenfolge;
Tiefensortier-Algorithmus:
- Voraussetzung: Polygone auch mit zyklischer Überlappung
- Verfahren: Zeichnen gemäß Betrachterabstand, Ausschlusskriterien steigender Komplexität,
Austausch bei falscher Reihenfolge, Reihenfolge, Zerlegen bei bei wechselseitigen Abhängigkeiten
Abhängigkeiten
1 Sortiere alle Polygone nach ihren kleinsten z-Koordinaten;
2 Wähle entferntestes Polygon P{
3 P überlappt in x, y oder z kein Polygon:
Rasterkonvertierung von P; �2
4 Wähle ein Polygon Q{
5 Hüllenvolumen von P und Q überlappen sich nicht in x?
6 Hüllenvolumen von P und Q überlappen sich nicht in y?
7 P liegt komplett hinter Ebene von Q?
8 Q liegt komplett vor Ebene von P?
9 P und Q überlappen sich nicht in xy?
10 if(5||6||7||8||9) �4
11 else if(P ist nicht markiert){
markiere Q; vertausche P und Q; �2}
12 else{teile P an Grenzen zu Q; �2}}
13 Rasterkonvertierung von P; �2}

174
Algorithmen mit Rasterlinien
Bildraum-Linien/Flächen-Algorithmen g
Scan-Line-Algorithmus:
- Voraussetzung: sich nicht durchdringende Polygone
- Verfahren: Polygonrasterkonvertierung yg g bei ggleichzeitiger g Behandlung g mehrerer Polygone yg
- Datenstrukturen: Kantentabelle ET, Polygontabelle PT, Aktive Kantentabelle AET
Sortierung der Kanten nach y- und x-Werten,
Verweis auf Polygone, x-Differenz zu nächster Scan-Linie, Flags für Bereiche und Übergänge
- Effizienzsteigerung durch durch Nutzung Nutzung von Rasterlinien Rasterlinien- und Kantenkohärenz auf Basis Basis der Tabellen
- Vorteil: jedes Pixel nur einmal behandelt
- Erweiterungen auf Zeichnen von Flächen
Füge Kanten aus aus PT in in ET ein;
Initialisiere AET;
for(jede Rasterlinie){
Aktualisiere AET aus ET;
for(jedes Pixel){
Setze Bereich-Flags(in,out);
Bestimme auf Pixel projizierende
Kantenpaare aus AET;
Bestimme nächstgelegenes nächstgelegenes Kantenpaar;
Bestimme Wert für Pixel aus PT;
Zeichne Pixelwert;}}
AET: : a AB,AC , C
b AB,AC,FD,FE
g,g+1 AB,DE,CB,FE
g+2 AB,CB,DE,FE

175
Algorithmen mit Flächenunterteilung
Warnock Warnock-Algorithmus:
Algorithmus:
- Bildraum-Flächen-Algorithmus
- Voraussetzung: Polygone
- Verfahren: Verfahren: schrittweise rekursive rekursive Unterteilung in kleinere weniger weniger komplexe komplexe Bereiche Bereiche
- Nutzung von Bereichskohärenz
- 4 Beziehungen Polygon - Bereich: umgebend, schneidend, enthaltend, disjunkt
if(kein Polygon im Bereich){
Bereich){
Füllen Hintergrundfarbe;} //1
if(nur ein schneidendes oder enthaltenes Polygon im Bereich){
Füllen Hintergrundfarbe; //2
Zeichnen Polygon mit mit Polygonfarbe;}
if(nur ein überdeckendes Polygon im Bereich){
Füllen mit Polygonfarbe;} //3
if(ein überdeckendes Polygon im Bereich, das
alle anderen Polygone Polygone in zz überdeckt){
Füllen mit Polygonfarbe;} //4
if(Bereich hat Pixelgröße){
Füllen mit Farbe des am Pixelmittelpunkt
nächsten Polygons;}
Polygons;}
if(sonst){
Zerlegung des Bereiches in Teilbereiche;
Aufruf für jeden Teilbereich;}

176
Weiler-Atherton Algorithmus:
- Objektraum-Linien/Flächen-Algorithmus
- VVoraussetzung: t PPolygone l
- Verfahren: Unterteilung von Polygonen entlang von Polygonkanten
- Nutzung von Bereichskohärenz
- Polygonlisten, yg , Stack zur Erkennung g zyklischer y Überlappungen pp g
void WAVisibilitySurface(void){
polygon *polyList=list of polygons;
sortiere polyList fallend nach maximalem z-Wert;
lö lösche h stack; t k
while(polyList!=NULL)
WASubdivide(firstpolygon on polyList,&polyList);}
void o d WASubdivide(polygon Subd de(po ygo cclipPolygon,polygon p o ygo ,po ygo **polyList){
po y st){
polygon *inList=NULL, polygon *outList=NULL;
for(jedes polygon in *polyList){
klippe polygon an Vorfahre von clipPolygon;
speichere p innere Teile in inList und äußere Teile in outList;} ;}
entferne polygone hinter clipPolygon aus inList;
for(jedes polygon in inList
und nicht auf Stack
und nicht Teil von clipPolygon){
p yg ){
push clipPolygon auf stack;
WASubdivide(polygon,&inList);
pop stack;}
for(jedes (j ppolygon yg in inList){ ){
display polygon;}
*polyList=outList;}

177
Sonstige Verfahren
Algorithmen g für gekrümmte g Flächen:
- Approximation durch Polygone möglich aber nicht immer effizient; Verwendung analytischer
Darstellungen erfordert Anpassung der Algorithmen
Algorithmen g mit Octrees:
- Verwendung einer hierarchischen Struktur räumlich dicht angeordneter disjunkter Würfel, die
den Raum unterteilen, zur Effizienzsteigerung
Algorithmen g mit BSPs:
- Verwendung einer hierarchischen Struktur binärer Zerlegungen des Raumes durch mehrere Ebenen
zur Effizienzsteigerung
Algorithmen g mit Ray y Casting: g
- Verwendung des Ray Tracing zur Ermittlung sichtbarer Flächen; Verfolgung eines virtuellen
Lichtstrahls vom Betrachter durch Bildschirmpixel auf Objektoberflächen der Szene
Darstellung verdeckter verdeckter Kanten Kanten und und Flächen
- keine Darstellung
- anderes Linien- oder Flächenmuster
- andere d Farbe F b
- freier Raum um verdeckende Kanten (haloed Lines)
Kriterien te e für ü Rastergrafikalgorithmen:
aste g a a go t e :
- Funktionalität - Systemunabhängigkeit
- Effizienz - Hardwarerealisierbarkeit

178
13. Geometrische
Transformationen
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Grundlegende 2D und 3D Transformationen der Geometrie
• Verwendung als geometrische Basis der Computergrafik
Abschnitte:
- Affine Räume
- 2D Koordinatensysteme
- Elementare 2D Transformationen
- Komposite i 2D 2 Transformationen f i
- 3D Koordinatensysteme
- Elementare 3D Transformationen
- Komposite 3D 3D Transformationen
- Wechsel von Koordinatensystemen Transformationen in der
2D und 3D Geometrie

179
Affine Räume
Vektorraum: Vn - Menge von Vektoren V, mit Nullvektor als neutrales Element (ursprungsorientiert)
- Operationen: Operationen: - Addition von Vektoren liefert Vektor (kommutativ, assoziativ)
- Multiplikation von Vektor und Skalar liefert Vektor (distributiv, assoziativ)
- Linearkombination von Vektoren und Skalaren spannen Bereich auf a1v1+a2v2+…+anvn Affi Affiner RRaum: A An - Menge von Punkten P und zugeordneter Vektorraum V, ohne neutrales Element (ursprungsinvariant)
- Operationen: - Differenz von Punkten liefert Vektor (eindeutig)
- Addition von von Punkt Punkt und Vektor liefert Punkt Punkt (eindeutig)
- Affinkombination: von Punktpaaren und Skalaren spannen Bereich auf p1+t2(p2-p1)+…+tn(pn-p1) Koordinatensystem: Kn - ZZusammenfassung f von ausgezeichneten i h Punkten P k (Ursprung (U und d Ei Einheitspunkten)
h i k )
- kartesisch: Ursprung und Einheitspunkte, Punkt als Linearkombination (o,e1,e2,…,en) - baryzentrisch: Punkte und Eins-Teilung, Punkt als Affinkombination (p1,p2,…,pn) Koordinaten: kn - kartesisch: p=(a1,a2,…,an) mit p=a1e1+a2e2+…+anen - baryzentrisch: p=(t1,t2,…,tn) mit p=t1p1+t2p2+…+tnpn und t1+t2+…+tn=1

180
Unterraum: Br - linear: r-dimensionale Teilmenge des Vektorraumes
- affin: r-dimensionale Teilmenge des affinen Raumes, für die ein r-dimensionaler Vektorraum
existiert
- Hyperebene Hyperebene ist Unterraum der der Dimension r=n r=n-1 1 (speziell Ebene, Ebene Gerade, Gerade Punkt)
n n
Lineare Abbildung: L : V1
�V2
- Abbildung zwischen Vektorräumen, die als Linearkombination darstellbar ist
n n
Affine Abbildung: � : A1 � A2
- Abbildung zwischen affinen Räumen, die als Affinkombination darstellbar ist
- Zusammenfassung linearer linearer und nichtlinearer nichtlinearer translativer Abbildung Abbildung
- Eigenschaften: Beschränktheit, Parallelität, Längenverhältnisse, Teilungsverhältnisse,
Kollinearität bleiben erhalten
- Längen, Winkel, Flächen- und Rauminhalte können sich verändern
- z.B. Rotation, Skalierung, Translation, Scherung, Spiegelung
- z. B. parallele Projektion, aber keine perspektivische Projektion
Ziel: einheitliche theoretische Grundlage Grundlage für für alle geometrischen geometrischen Darstellungen
Darstellungen
sowie deren Transformationen

181
2D Koordinatensysteme
Homogene Koordinaten
Homogene Koordinaten erlauben durch Hinzufügen einer Koordinate zu kartesischen Koordinaten
die einheitliche Behandlung aller Transformationen über Multiplikation.
P
(0,0,1) (x/W,y/W,1)
x
W=1
Prinzip:
- kartesische Koordinaten: (x,y) W
- homogene Koordinaten: (x,y,W)
- W=1: kartesische Ebene, W=0: Punkte im Unendlichen
- Homogenisierung: Division durch W (x/W,y/W,1)
- kartesischer Punkt hat hat mehrere mehrere homogene Darstellungen:
(x,y,W)=(kx,ky,kW)
- k=const: homogene Gerade
y
Vorgehen:
- Erzeugung homogener Koordinaten: Pk=(x,y) � Ph=(x,y,1) - Transformationen: Ph � Ph' - Erzeugung kartesischer Koordinaten: Ph'=(x,y,W) � Pk'=(x/W,y/W) y
2D Koordinatensystem:
- System aus 2 orthogonalen Achsen x, y
mit Schnittpunkt im Koordinatenursprung
- positiver i i Drehsinn: D h i gegen Uhrzeigersinn
Uh i i
x

182
Elementare 2D Transformationen
Veränderung der Lage von Punkten Punkten in der xy-Ebene xy Ebene durch durch Verschieben, Verschieben Vergrößern und und Drehen
Translation:
- Verschieben eines Punktes in der Ebene
parallel zu x- und y-Achse um die Abstände tx und ty - Skalarform: x'� x �t
x y'�
y � t y
- Matrixform: P'� P � T
� �
� �
� �
�
� �
� �
� �x' x tx
� � � � � � � �
�y'� �y�
�t
y �
Skalierung:
- Vergrößern g eines Punktes bezüglich g Koordinatenursprung p g
parallel zu x- und y-Achse um die Faktoren sx und sy - Skalarform: x'� sx
� x y'�
sy
� y
- Matrixform: P'� S � P
� �
� �
� �
� �
� �
� �x' sx
0 x
� � � � � � � �
�y'�
� 0 s y � �y�
Rotation:
- Drehen eines Punktes bezüglich Koordinatenursprung
um den Winkel �
- Skalarform: x'�
x �cos�
� y �sin�
y'�
x �sin�
� y �cos�
- Matrixform:
P'� R � P
� �
� �
� �
� � �
� �
� �x' cos�
sin�
x
� � � �
� � � �
�y'�
�sin�
cos�
� �y�
Skalierung, Rotation auch bezüglich eines beliebigen Punktes

183
2D Transformationen in homogenen Koordinaten
Darstellung der der 2D Transformationen mit Hilfe von von 3D 3D homogenen homogenen Koordinaten
Koordinaten
� ��
� �
�
x
y
1
� ��
� �
�
��
� ��
0
0
� �
0
1�
x x 0
y ��
y
s
0
s
0
0
� ��
�
��
� ��
'
y'
� �
1 �
� ��
�
��
��
� ��
�
�x'� �1
a 0�
�x
� ��
�
�
� �
��
�
� �
��
�
�
� �
��
�
� �
��
�x
1 a 0 x
y'
b 1 0 y
�1
0 0 1 1
Translation:
(homogen)
� ��
� ��
� ��
� ��
� ��
� ��
x' 1 0 t x
Skalierung:
x
( g )
(homogen)
y'
0 1 t y
� �
� �
�
�
� �
�
� �
�
�
� �
�
� �
�
( g )
y 0 1 t y y
inkl. Reflexion
�1
0 0 1 1
Rotation: �x'� �cos� � sin�
0�
�x�
Scherung:
� ��
�
� �
��
�
�
� �
��
�
� �
��
�
�
� �
��
�
� �
��
�
(homogen) (homogen)
y' sin�
cos�
0 y
b=0: an x-Achse
�1
0 0 1 1 a=0: an y-Achse
�� Parallelogramm
Eigenschaften der Rotationsmatrix:
(linke obere 2x2-Matrix mit Zeilenvektoren):
- orthogonale Einheitsvektoren
- Determinante 1
- Rotation der Vektoren auf positive Koordinatenachsen
�
�
��
� y
x
�t
�
��
t
Transformationsmatrix:
- Festkörper-Transformation:
reine Rotationsmatrix: Erhaltung von Winkel und Längen
- Affine Transformation:
beliebige Parameter Erhaltung von Parallelität
� ��
� ��
r11
r12
tx
�r11
r12
�
R � � � T
M � r21
r22
t y �r21
r22
�
beliebige Parameter, Erhaltung von Parallelität
�
Realisierung:
�
� �
�
� 0 0 1
Ph '�
M � Ph
x'� x �r11
� y �r12
� tx
y'� x � r21
� y � r22
� t y
Pk '�
R � Pk
�T

184
Komposite 2D Transformationen
Nacheinanderausführen von von affinen affinen 2D Transformationen durch sukzessives Multiplizieren von von
Transformationsmatrizen
Aufgabe: Aufgabe: komplexe Transformation Transformation eines durch Punkte Punkte definierten definierten Ausgangsobjektes
Vorgehensweise:
- Zerlegung der komplexen Transformation in elementare Transformationen
- Zuordnung Zuordnung von Transformationsmatrizen zu zu elementaren Transformationen
- Transformationsmatrizen werden in Reihenfolge der Anwendung von rechts nach links multipliziert
- Ergebnis ist eine gesamte Transformationsmatrix für die komplexe Transformation
- Gesamte Transformationsmatrix wird von links mit den Punkten des Objektes multipliziert
- JJede d TTransformation f i durch d h 1 Matrixmultiplikation M i l i lik i abbildbar bbildb
Ergebnis: durch transformierte Punkte definiertes Zielobjekt
Beispiel (1): (1):
)
M � T ( x2,
y2
) � R(
� ) � S(
sx
, sy
) �T
( �x1,
� y1
1
P
P � M �
2
Beachtung:
- Transformationen sind allgemein
assoziativ, , aber nicht kommutativ.
- Reihenfolge der Anwendung ist
relevant.

185
Beispiel (2):
M � T ( x1,
y1)
� R(
� ) �T
( �x1,
�y1
)
� ��
� ��
x1
�
P1
� y1
��
� ��
x1
P1
'� y1
1' P1
M P � �
( 1,
y1)
( ) ( 1,
y1)
� � �
�� � 1 �
� �
�� � 1
� �
� � � � �
� �
� � �
� �
� � �
� �
� �1 0 x1
cos�
sin�
0 1 0 x1
cos�
sin�
x1(
1 cos�
) y1
sin�
� ��
� �
��
�
� �
� �
��
� �
��
� �
� �
��
� �
��
�
� �
��
� �
�
�
0 1 y1
sin�
cos�
0 0 1 y1
sin�
cos�
y1(
1 cos�
) x1
sin�
�0
0 1 0 0 1 0 0 1 0 0
1
�
M
Beispiel (3):
)
M � T ( x1,
y1)
� S(
sx
, sy
) �T
( �x1,
�y1
� �
� �2
� �
�
� �
��
4
�1
�
1
P
� �
2 1 x1s
x
1' � y1s
y
� � sx
� x �
� �
�
4s
y � y1
�
� 1
P
� �
� � �
� �
� � �
� �
� �
� �
� � 1 0 x1
sx
0 0 1 0 x1
sx
0 x1(
1 sx
)
� ��
� �
��
�
�
� �
��
� �
��
� �
� �
��
� �
�
�
�
� �
�
�
� �
�
�
0 1 y1
0 sy
0 0 1 y1
0 sy
y1(
1 sy
)
�0
0 1 0 0 1 0 0 1 0 0 1
�
M
� ��
�

186
3D Koordinatensysteme
Kartesisches Koordinatensystem für für 3 Dimensionen und und dessen dessen Darstellung in homogenen homogenen
Koordinaten
Prinzip: Prinzip:
- kartesische Koordinaten: (x,y,z)
- homogene Koordinaten: (x,y,z,W)
- W=1: kartesischer 3-Raum
- Homogenisierung: i i Division i i i durch d h W ( (x/W,y/W,z/W,1)
/ / / )
- Darstellung eines Punktes im kartesischen 3-Raum als Gerade im homogenen 4-Raum
P=(kx,ky,kz,kW)
Vorgehen:
- Erzeugung homogener Koordinaten: Pk=(x,y,z) � Ph=(x,y,z,1) - Transformationen: Ph � Ph' - Erzeugung kartesischer Koordinaten: Koordinaten: P Ph'=(x,y,z,W) h (x,y,z,W) �� P Pk'=(x/W,y/W,z/W) k (x/W,y/W,z/W)
y
3D Koordinatensystem:
- rechtshändiges System: Rechte-Hand-Regel für Achsen x, y, z
- positiver Drehsinn: entgegen entgegen des des Uhrzeigersinnes
bei Blick in Richtung negativer Rotationsachse
x
z

187
Elementare 3D-Transformationen
Darstellung der 3D Transformationen mit Hilfe von 4D homogenen Koordinaten
Skalierung:
(h ) � �
� �sx 0 0 0
(homogen)
inkl. Reflexion
� ���
�
�
���
0 sy
0 0
S(
sx
, sy
, sz
) �
0 0 sz
0
��
0 0 0 1�
Translation:
(h ) � �
� �1 0 0 tx
(homogen)
� ���
�
�
���
0 1 0 t y
T ( tx
, t y,
tz
) �
0 0 1 tz
��
0 0 0 1 �
Rotation um z-Achse:
Scherung:
(homogen)
(homogen)
an z-Achse,
� ���
� ���
cos�
� sin�
0 0
sin�
cos�
0 0
R ( � ) �
� ���
� ���
1 0 shx
0
0 1 shy
0
an z Achse, SH ( sh , sh ) �
�
an y-Achse,
an x-Achse
� Parallelepiped
�
Rz
(� )
� 0 0 1 0
�
�
� 0 0 0 1�
�
SH xy ( shx,
shy
)
�0
0 1 0
�
�0
0 0 1�
Rotation um um y-Achse: y Achse: � cos� 0 sin�
0�
�1 sh 0 0�
(homogen)
� ���
�
�
�
���
� cos�
0 sin�
0
0 1 0 0
Ry
( � ) �
� sin�
0 cos�
0
�
� 0 0 0 1
���
�
�
�
���
�1
shx
0 0
0 1 0 0
SH xz ( shx,
shz
) �
0 shz
1 0
�
�
�
�
� 0 0 0 1�
��
0 0 0 1 1�
� ��
0
0
� ��
0
0
1�
0
0
1
0
0
1
0
0
1
y
sh
sh
0
� ��
0 0
� sin�
0
� ��
sin�
0
cos�
0
0 1�
0
cos cos��
sin�
0
� ��
1
0
� �
�
0
0
�0
Rotation um x-Achse:
(homogen)
( � )
� ��
� �
�
�
�
)
z
sh
,
y
sh
(
yz
SH
�
x
R
z

188
� ���
0
0
0
� � 0
1�
Rotation um 3 Koordinatenachsen:
- Winkel: W � � , ��
, ��
(Reihenfolge)
( g )
� ���
cos�
cos�
� cos � sin �
� sin �
sin�
sin � cos�
� cos�
sin � cos�
cos�
� sin�
sin � cos�
sin�
cos �
R(
�,
�,
� ) �
� cos cos�� sin ��
cos cos��
��
sin sin��
sin ��
� cos cos��
sin ��
sin ��
� sin sin��
cos cos��
cos cos��
cos ��
�
�
0
0
0
�
� ����
0
0
0
�
1�
xz(
1�
cos�
) � y sin�
yz(
1�
cos�
) � xsin�
zz(
1�
cos�
) � cos�
0
Rotation um beliebige Achse durch Koordinatenursprung:
- Achse in Richtung des normierten Vektors (x,y,z)
- Winkel �
�
� ����
xx(
1�
cos�
) � cos�
xy(
1�
cos�
) � z sin�
xy(
1�
cos�
) � z sin�
yy(
1�
cos�
) � cos�
R(
x,
y,
z,
�)
�
xz(
1�
cos�
) � y sin�
yz(
1�
cos�
) � xsin�
�
� 0
0
RRotation t ti um beliebige b li bi Achse A h iim Raum: R
Zusammengesetzte Transformation:
- Verschiebung des Rotationszentrums in den Koordinatenursprung
- Rotation um normierten Vektor
- Zurückverschiebung in das Rotationszentrum

189
Eigenschaften der Matrizen:
- linke obere 3x3-Matrix der Rotationsmatrizen: orthogonale Zeilenvektoren, Einheitsvektoren,
Determinante 1
�1 T
- Orthogonalmatrix: R � R
- Inverse: - Translation: Negation der Verschiebungen � t x , � t y , � t z
�1
MM
- Skalierung: Reziproke der der Vergrößerungen
Vergrößerungen 1 / s x , 1 / s y , 1 / s z
- Rotation: Negation des Winkels � �
�1
�1
�1
- komplexe Transformation: ( M � M ) � M � M
1
2
2
1
� ��
� ��
r11
r12
r13
tx
Ph '�
M � Ph
r21
r22
r23
t y
M �
� P ' R P T
��
� ��
r11
r12
r13
R � r21
r22
r23
� ��
� ��
tx
T � t y
� ��
�
�
��
M �
P
r31
r32
r33
t
k '�
R � Pk
�T
z
�
� 0 0 0 1
�
� �
�
�r31 r32
r
� 33
�
� �
� y
�tz Transformationsmatrix:
(homogen)
Angabe von Rotationswinkeln:
- Eulerwinkel: Winkel in Bezug auf ein ortsfestes Koordinatensystem
- Winkelbezeichnungen: Nickwinkel (x, Pitch), Pitch), Gierwinkel (y, (y, Yaw), Yaw), Rollwinkel(z, Roll)
- Gimbal Lock: Verlust eines Rotationsfreiheitsgrades unter bestimmten Bedingungen
- Beispiel: 45° z, 90° y, 45° x � Ausgangszustand
- Lösung: zweites, mitrotierendes Koordinatensystems als Bezug für Winkel
QQuaternionen i

190
Komposite 3D Transformationen
Nacheinanderausführen von von affinen affinen 3D Transformationen durch sukzessives Multiplizieren von von
Transformationsmatrizen
Aufgabe: Aufgabe: komplexe Transformation Transformation eines durch Punkte Punkte definierten definierten Ausgangsobjektes
Vorgehensweise:
(1) Komposition elementarer Transformationen und deren Anwendung auf die Punkte des Objektes
(2) Ausnutzung Ausnutzung der Eigenschaften von von orthogonalen Matrizen (Zeilenvektoren auf auf Koordinatenachsen)
Koordinatenachsen)
Beispiel:
(1) Punkttransformation
)
M � R � T � R Rz
( � ) � R Rx
( ��
) � R Ry
( ��
) � T ( �x1,
�y1
, �z1
(2) Vektortransformation
1z
P1
P2
Rz r2
z �
P1
P2
r � ��
� �
��
1x
�
Rx r2
x
�
�r ��
�
�� r � 3z
�
���
3
r
�
r
�
2
1
3
1
2
P
P
1
P
P
�
�
3
P
P
1
P
P
�
�
�
� ��
r x ��
�
1
x
�
�
0
0
� ��
� �
�
�
y
0
1
� ��
1
0
� �
�
0
�0
x
x
x
1
0 0 1 1
��
y
y
y
� ��
r1
r1
� �� r1
� 0
��
M
x
R
� z
1
� ��
0
0
� ��
1�
z
r y
R r � � R �
��
� ��
1
Ry � r y � Rz
�
r �
y
�
�
�
� � 2
� 3
0
0
r3
r3
r3
0
z
r2
r2
r2
0
z

191
Wechsel von Koordinatensystemen
Darstellen von von Objekten Objekten in unterschiedlichen unterschiedlichen Koordinatensystemen, Koordinatensystemen z.B. z B Darstellen mehrerer mehrerer in
lokalen Koordinatensystemen definierter Objekte in einem einheitlichen globalen Koordinatensystem
Gleichwertige Denkalternativen für Transformationen:
- Bewegung von Punkten in einem festen Koordinatensystem
- Bewegung des Koordinatensystems bei festen Punkten
j
M �
)
i
k
(
P
Vorgehensweise:
( i)
( j)
( k )
- Punkte in den Koordinatensystemen i, j, k: P , P , P
- elementare Transformationsmatrix zwischen den Koordinatensystemen j und i:
( i)
( j)
( j)
- elementare Koordinatensystemtransformation: P � M i�
j � P , P � M j�k
�
- komposite Koordinatensystemtransformation:
Koordinatensystemtransformation: ( i )
( k )
P � M i�
j � M j�k
� P
- komposite Koordinatensystemtransformationsmatrix: M i�k
� M i�
j � M j�k
1
�
M i�
j � M
Regeln:
- Koordinatensystemtransformation:
Inverse der Transformation im Koordinatensystem:
- Koordinatensystemtransformation einer
( i)
( j)
�1
Transformation: M M � M � M
� i�
j
i�
j
)
2
,
4
(
�
)
4
(
Beispiel (1):
( 1)
( 2)
( 3)
P � ( 10,
8),
P � ( 6,
6),
P � ( 8,
6),
P
( 45�)
R
�
)
2
,
6
(
T
�
� T ( 4,
2),
M 2�3
� T ( 2,
3)
� S(
0.
5,
0.
5),
M 3�4
1�2
M
1�4 1�2
2�3
3�4
� M � M � M
M

192
7
x1
� 6 y1
�
M � T ( x , ) ( , ) ( , )
P0' � M � P
1 y1
� S sx
s y �T
�x2
�y
2
0
s sx � 2 s sy
� 1
�1
�1
( 4)
( 1)
M 4�1
� T ( x2,
y2)
� S(
sx
, sy
) �T
( �x1,
�y1
) P0 � M 4�1
� P0
x2
� 4 y2
�
Beispiel (2):
5
�2� �2s � x � s x � �2�
� ��
�
� �
��
�2s
x � x1
sx
x2
P0 '� 3sy
� y1
� sy
y2
�
� 1
��
�
� �
��
�
3
�1
� ��
�
� �
��
�2
� 5
�1
��
2
�
0
P
2
� ��
�
�1 0 x � �s
0 0�
�1 0 � x � �s 0 x � s x
� ��
�
�
�
� �
��
�
� �
��
�
� �
� �
��
�
� �
��
�
�
� �
��
�
� �
��
�1
0 x1
sx
0 0 1 0 x2
sx
0 x1
sx
x
0 1 y1
0 sy
0 0 1 y2
0 sy
y1
s y
�0
0 1 0 0 1 0 0 1 0 0 1
M �
y
� ���
� ���
1
� � 2
� �
� �
�
� 1
1
x
�1
x2
� sx
( 4)
�1
P0 � y2
� sy
1
x
1
y
1
y
�1
�1
�1
0 x2
sx
0 0 x1
sx
0 x2
sx
�1
�1
�1
M 4�1
� 1 y2
� 0 sy
� 1 y1
� 0 sy
y2
sy
�
�
�
�
� ���
�
�
� ���
�
�
� ���
� ���
0
� 0
�� � �
�
�1 0
P
1
� ���
�
�
1
0
0
� ���
�
�
� ��
� �
�
1
0
� ��
1
0
� �
�0
� ���
0
0
1�
�
0
0
� ���
�
�
� ��
� �
�
1
0
� ��
1
0
� �
�0
BBeispiel i i l (3):
(3)

193
14. Geometrische Projektionen j
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziele:
• Grundlegende 2D und 3D Projektionen der Geometrie
• Verwendung als geometrische Basis der Computergrafik
Abschnitte:
- Projektive Räume
- Projektionen
- Spezifikation von 3D Sichten
- Beispiele für für 3D 3D Sichten
- Formale Darstellung von Projektionen
- Normalisierung von Sichtvolumen
- Implementation von Projektionen
Projektionen in der
2D und 3D Geometrie

194
Projektive Räume
g
Projektiver Raum: P(Vn )
- Menge aller Geraden durch den Ursprung eines Vektorraumes
- Betrachterstandpunkt q p
- speziell parallele Geraden mit Ursprung im Unendlichen
- eigentliche Punkte, uneigentliche Punkte (Fernpunkte, Richtungen)
- Punkte im projektiven Raum: e u
- Dimension: n-1 (projektive Gerade (1) Ebene (2) Raum (3))
P P P � �
g' p'
- Dimension: n-1 (projektive Gerade (1), Ebene (2), Raum (3))
- zwei Geraden sind windschief oder schneidend
q
- Operationen Addition oder Multiplikation nicht anwendbar
n
n
Projektive Abbildung: � : P( V1
) � P(
V2
)
- Abbildung zwischen projektiven Räumen (Punkt, Gerade, Ebene, Raum)
- eineindeutige als reguläre lineare Koordinatentransformation beschreibbare Abbildung
- Geraden und Flächen werden werden wieder auf auf Geraden Geraden und und Flächen abgebildet abgebildet
- Punktreihenfolgen auf Geraden bleiben erhalten
- z. B. perspektivische Projektion, orthogonale Projektion
)
4
3
Zusammenhang zwischen affinem und projektivem Raum: I : V � P(
V
- Affiner Raum lässt sich in projektiven Raum einbetten
- Abbildung in beide Richtungen
- zz. B. B Transformation zwischen kartesischen und und homogenen homogenen Koordinaten
Koordinaten
Ziel: einheitliche theoretische Grundlage für alle geometrischen Projektionen

195
Projektionen
Abbildung von Objekten eines eines n-dimensionalen n dimensionalen Raumes auf Objekte eines (n-1)-dimensionalen (n 1) dimensionalen Raumes Raumes
Projektion allgemein:
* AAufgabe: f b
- Abbildung speziell von Punkten des 3D Raumes auf Punkte der 2D Ebene (Beschränkung auf n=3)
* Vorgehensweise:
- Ve Verwendung e d von Projektoren: P jekt e : St Strahlen, hle die vom Projektionszentrum P jekti e t ausgehen, ehe durch d h die Punkte P kte der de
Objekte verlaufen und die Projektionsebene schneiden
* Klassen:
- Ebene geometrische Projektionen Projektionen (Projektionsflächen und und Projektionsstrahlen nicht nicht gekrümmt) gekrümmt)
- Perspektivische Projektion (endlicher Abstand Projektionszentrum - Projektionsebene)
Effekt: - Verkleinerung proportional zur Entfernung von Projektionszentrum
- Winkel und Parallelität parallel p zur Projektionsebene j
erhalten
- Parallele Projektion (unendlicher Abstand Projektionszentrum - Projektionsebene)
Effekt: - konstante Verkleinerungen entlang einzelner Achsen
- Längenverhältnisse und Parallelität erhalten, Winkel parallel zur Projektionsebene erhalten
- Gekrümmte geometrische geometrische Projektionen

196
Perspektivische Projektion:
* Fluchtpunkt:
- Punkt, k auf f den d parallele ll l Geraden, d die di nicht i h zur Projektionsebene j k i b parallel ll l sind, i d zulaufen l f
- Geraden parallel zur Projektionsebene haben keinen Fluchtpunkt (uneigentlicher Punkt)
- Hauptfluchtpunkt: Fluchtpunkt einer Koordinatenachse
- Hauptfluchtpunkte Hauptfluchtpunkte existieren für für alle Achsen Achsen (die die Projektionsebene Projektionsebene schneiden) schneiden)
* Klasseneinteilung:
nach Anzahl der Hauptfluchtpunkte
Hauptfluchtpunkte
- Einpunktprojektion (Perspektive in Richtung z-Achse mit einem Fluchtpunkt)
- Zweipunktprojektion (mit Fluchtpunkten auf 2 Achsen)
- Dreipunktprojektion (mit Fluchtpunkten auf 3 Achsen)

197
Parallele Projektion:
* Projektionsrichtung:
- Relation l i zwischen i h Richtung i h der d Projektion j k i und d Normale l der d Projektionsebene
j k i b
* Klasseneinteilung:
- Rechtwinklige / Orthogonale Projektion (Projektionsrichtung senkrecht zur Projektionsebene)
- GGrundriss, d i Aufriss, A f i Seitenriss S i i (6 (6 Projektionsrichtungen j k i i h entlang l Koordinatenachsen)
di h )
- Axonometrische Projektion (beliebige Projektionsrichtung ungleich einer Koordinateachse)
- Isometrische Projektion (Projektionsrichtung mit gleichen Winkeln zu jeder Koordinatenachse)
8 Varianten, Varianten, alle Längen Längen werden gleich gleich skaliert, Achsenwinkel Achsenwinkel 3 x 120 120°
- Dimetrische Projektion (gleicher Winkel zu zwei Achsen), Trimetrische Projektion (allgemeiner Fall)
- Schiefwinklige Projektion (Projektionsrichtung nicht senkrecht zur Projektionsebene)
Winkel von Projektionsrichtung zu Projektionsebene (beta) und zu x-Achse (alpha)
- KKavalierprojektion li j k i (Winkel (Wi k l beta: b arctan(1)=45°, (1) 45° Li Linien i senkrecht k h zur Projektionsebene P j k i b original) i i l)
- Kabinettprojektion (Winkel beta: arctan(2)=63°, Linien senkrecht zur Projektionsebene halbiert)
Winkel alpha: zur x-Achse in der Regel 30° oder 45°

198
Spezifikation von 3D-Sichten
Festlegung aller zur zur Bestimmung einer einer Projektionsart notwendigen notwendigen Parameter, Parameter insbesondere
insbesondere
Projektionsebene, Projektionszentrum, Sichtvolumen
Parameterspezifikation:
* Sichtebene / Projektionsebene VP: (in WC)
- Ebene, auf die die Objekte des 3D-Raums abgebildet werden
- Position und und Lage Lage beliebig (vor, (vor zwischen, zwischen hinter Objekten)
- Angaben im Weltkoordinatensystem WC
(1) Sichtreferenzpunkt VRP
(2) Sichtebenennormale VPN
* Sichtreferenzkoordinatensystem VRC: (in WC)
- Koordinatensystem (u,v,n) zur Definition eines Sichtfensters
- Ursprung: p g VRP, , n: VPN, ,
- v: Projektion eines Vektors VUP auf Sichtebene, u: implizit
(3) Sichtobenvektor VUP
* Sichtfenster S VW VW: (in ( VVRC) C)
- zu VRC achsenparalleles Rechteck in VP
- Fenstermittelpunkt CW implizit
(4) Minimaler horizontaler Wert umin
MMaximaler i l horizontaler h i t l Wert W t umax
Minimaler vertikaler Wert vmin
Maximaler vertikaler Wert vmax

199
* Projektionsrichtung DOP: (in VRC)
- Projektionstyp perspektivisch: PRP ist Projektionszentrum
- Projektionstyp parallel: (PRP,CW) (PRP CW) ist Projektionsrichtung
- PRP in VRC angegeben
- (CW,PRP) und (VRP,VPN) parallel oder nicht
(5) Projektionsreferenzpunkt PRP
(6) Projektionstyp PT
* Sichtvolumen VV: (in VRC)
- Bereich der Welt, der ausgeschnitten g und auf VP projiziert p j wird
- perspektivische Projektion: Pyramide mit PRP und VW
Volumen einseitig unendlich
- parallele Projektion: Parallelepiped mit PRP, CW und VW
Volumen zweiseitig unendlich unendlich
- zweiseitige Beschränkung in Projektionsrichtung durch
Definition von vorderer und hinterer Schnittebene parallel
zur Sichtebene
(7) Vorderposition F
Hinterposition B

200
Beispiele für 3D Sichten
Darstellung eines Hauses in durch verschiedene Projektionen erhaltenen Ansichten:
VRP(WC): (16,0,54)
VPN(WC): (1,1,1) (1 1 1)
VUP(WC): (0,1,0)
VW(VRC) (-20,20,-5,35)
PRP(VRC): (0,0,20)
PT: PAR
VV(VRC): (0,-100)
* Objekt in Weltkoordinatensystem
im Bereich x: [0,16], y: [0,16], z: [30,54]
y
(8,16,30)
x
(16,10,30)
VRP(WC): (16,0,54)
(0 (0,10,54) 10 54)
(16,0,30)
VPN(WC): (0,0,1)
VUP(WC): (0,1,0)
VW(VRC) (-20,20,-5,35)
(16,0,54)
PRP(VRC): (20,25,20)
z
PT: PER
VV(VRC): (0,-100)
* Parallele (isometrische) Projektion:
(CW,PRP), (VRP,VPN) parallel
VRP(WC): (16,0,54) (16,0,54)
VPN(WC): (1,0,1)
VUP(WC): (0,1,0)
VW(VRC) (-20,20,-5,35)
PRP(VRC): (0,25,28) (0,25,28)
PT: PER
VV(VRC): (0,-100)
* Perspektivische (Einpunkt-) Projektion
(CW,PRP), (VRP,VPN) nicht parallel
* Perspektivische (Zweipunkt-) (Zweipunkt ) Projektion
(CW,PRP), (VRP,VPN) nicht parallel

201
* Perspektivische Projektion:
zentrische Projektion
* Parallele Projektion:
Seitenriss
y
x
VRP
v
u
n
z
VRP(WC): (8,6,54)
VPN(WC): (0,0,1)
VUP(WC): (0,1,0)
VW(VRC) ( (-9,9,-7,11) 9 9 7 11)
PRP(VRC): (0,0,30)
PT: PER
VV(VRC): (1,-55)
PRP
y
VRP(WC): (0,0,54)
VPN(WC): (1,0,0)
VUP(WC): (0,1,0) (0,1,0) x
VW(VRC) (-1,25,-5,21)
PRP(VRC): (12,8,16) VUP v u
PT: PAR
VRP
VV(VRC): (17, (17,-1) 1)
PRP
n
z VPN

202
Formale Darstellung von Projektionen
Mathematische Beschreibung Beschreibung von ebenen geometrischen Projektionen Projektionen mittels Vektoren Vektoren und und Matrizen
Parallele Projektion:
Perspektivische Projektion:
* AAnnahme: h
* AAnnahme: h
- Sichtebene orthogonal zur z-Achse bei z=0 - Sichtebene orthogonal zur z-Achse bei z=0
- Projektionszentrum bei z � �d
- Projektionszentrum bei z � ��
* BBerechnung: h x' x x y' y y
�
�
* B h
' ' ' 0
- Strahlensatz: d z � d d z � d
* Projektionsmatrix:
(h )
� �
� � * Berechnung: x'�
x y'�
y z'�
0
z'�
0
1 0 0 0
- Grenzübergang: M par ( d)
� lim M per ( d)
d ��
- (homogene)
* M t i d t ll
� ���
�
�
���
0 1 0 0 * Matrixdarstellung:
M per �
0 0 0 0
- Projektionsmatrix:
�0
0 1/
d 1
� ����
� ����
1 0 0 0
0 1 0 0
M par �
0 0 0 0
* Anwendung:
� �
�0
0 0 1�
- Gleichung:
� ����
� ����
� �
� ����
� ����
x'
x
y'
y
P'� M P
M
per �
per
z'
z
� � � �
�w'�
�1�
- Ergebnis:
P'
� ��
� ��
� ��
� ��
x'
x
y'
y
� ��
� ��
�
�
�
��
� ��
x
P(x,y,z)
x'
/ w'
dx /( z d)
P'(x',y',z')
y'
/ w'
dy /( z d)
PRP
x'
x
� ��
�
�
��
�
�
� �
��
�
�
��
y y
z'
0
�
�w'
z / d 1
��
�
�
��
�
�
�
�
��
�
�
�
�
y / w dy /( z d)
PRP
x
d
z
z'
/ w'
0
z
� 1 1

203
Allgemeine Projektion:
* Ziel:
- einheitliche Behandlung aller Projektionen
- Zulassung beliebiger Positionen und Lagen von Punkten, Vektoren und Ebenen
- Einschränkung: g Projektionsebene j senkrecht zu z-Achse (Einpunktprojektion, ( p p j , ohne Rotation) )
� ���
d x d
Berechnung von Fluchtpunkt oder
x
� z'
d z d
Projektionsreferenzpunkt:
z
d d
� ����
d y d y
� z'
d z d z
2
z'
z'
� � z'
Qd Qd
� ����
� ����
0
0
F � gen
1
M P
x � Qd x
y � Qd y
z � z'
� ���
Qd z Qd z
� � 2 2 2
1 z'
�0� d x � d y � d z �1
� �1
Qd z Qd z �
0
� ���
1
0
* Projektionsmatrix:
(homogen)
1
�
gen
M
0
� ���� 0
0
� ��� 0
�
mit Einheitsvektor D und Abstand Q
* Ableitung spezieller Projektionen:
PRP
x
M: z': Q: d x: d y: d z:
P'(x',y',z')
P( P(x,y,z) )
z
Q
D=(dx,dy,dz) (0,0,z')
Mort 0 � 0 0 -1
M per 0 d 0 0 -1
Mcav 0 � cos�
sin�
-1
Mcab 0 � cos� 2 sin� 2 -1

204
Normalisierung von Sichtvolumen
Überführung von Sichtvolumen in eine kanonische Form zur effizienten Ausführung des Klippens
Normalisierung:
* Generelle Vorgehensweise
- Reduzierung von Sichtvolumen unterschiedlicher Größe auf eine einheitliche Größe
- Überführung von von pyramidenförmigen Bereichen in Einheitsquader
- dadurch Reduzierung der Kosten für spätere Operationen
* Parallele Projektion
- TTranslation l ti von VRP VRP zum Ursprung U
- Rotation von VRC, dass Achsen n - z, u - x, v - y inzidieren
- Scherung, dass Projektionsrichtung parallel zur z-Achse liegt
- Translation, , Skalierung g in kanonisches paralleles p Sichtvolumen
- Matrix: � S �T
� SH � R �T
( �VRP)
N par par par par
* Perspektivische Projektion
- Translation von von VRP zum zum Ursprung Ursprung
- Rotation von VRC, dass Achsen n - z, u - x, v - y inzidieren
- Translation von PRP zum Ursprung
- Scherung, g dass Mittellinie des Sichtvolumens z-Achse wird
- Skalierung in kanonisches perspektivisches Sichtvolumen
- Matrix: N per �
S per � SH par �T
( �PRP)
� R �T
( �VRP)

205
* Überführung von perspektivischer in parallele Projektion
- Überführung von pyramidenförmigen Bereichen in in Einheitsquader
- Transformation von perspektivischem in kanonisches paralleles Sichtvolumen
� �
� �1 0 0 0
� ����
0 1 0 0
1 � z
0 0
1�
zmin
1�
z
���
0
0 � 1 0
per
N
par
N' per � M per per��
min
�
M per�
par
� ����
���
min

206
Implementation von Projektionen
Algorithmische Umsetzung Umsetzung der der Projektionskonzepte in der der gesamten gesamten Rendering Pipeline
Anwendungsprogramm
Notwendige g Einzelschritte:
Homogene Erweiterung
Modelltransformation
Normalisierungg
Sichtvolumenklippen
Sichtebenenprojektion
* Homogene Erweiterung
- Übergang zu homogenen Koordinaten (Erweiterung)
* Modelltransformation
- Operationen im 3D Raum gemäß Anwendungsmodell (Transformation)
* Normalisierung
- Transformation in ein kanonisches Sichtvolumen (Transformation)
* Sichtvolumenklippen
- Abschneiden nicht sichtbarer Modellbestandteile (Klippen)
* Sichtebenenprojektion
- Überführung g in 2D-Ebene (Projektion) ( j )
* Viewportabbildung
- Überführung in Fenster- bzw. Gerätebereiche (Transformation, Klippen)
* Homogene Reduzierung
- Übergang zu kartesischen kartesischen Koordinaten (Division)
Viewportabbildung
Homogene g Reduzierungg
Ziel: - effiziente strukturelle und und algorithmische algorithmische Realisierung
Realisierung
- mehrere Operationen in einer Transformationsmatrix
Anzeigegeräte

207
15. Mathematische Grundlagen g
Prof. Dr.-Ing. habil. Wolfgang Oertel
Ziel:
KKennenlernen l ausgewählter ähl mathematischen h i h Grundlagen G dl der d Computergrafik
C fik
Sammlung wichtiger Formeln
Abschnitte:
• Anwendungsgebiete
• Zahlenlehre
• Mengenlehre
• Koordinaten
• Trigonometrie
• Planimetrie
• Stereometrie
• Interpolation
• Vektoralgebra
• Matrizenalgebra
Schwerpunkt: Mathematische Formeln

208
Anwendungsgebiete
Einsatz mathematischer Verfahren für computergrafische Aufgabenstellungen
Anwendungsgebiete:
Anwendungsgebiete:
- Kurven
- Flächen
- Körper
- Beleuchtung
- Rendern
- Transformation
- Projektion
- Rastern
- Füllen
- Sichtbarkeit

209
Zahlenlehre
Zahlenbereiche und deren Operationen
Zahlenbereiche:
Zahlenbereiche:
- natürlich: diskret, Strahl N
- ganz: diskret, Linie G
- rational: gebrochen, g Linie R
- reell: dicht, Linie P
- komplex: dicht, Fläche C
i��
i�
z �� re e ��
1 ��
0
z � � a ��
bi z ��
r (cos (cos�� ��
i sin sin��
)
n m
a
m / n
a �
� mn
a
Operationen:
- kommutativ, , assoziativ, , distributiv
m�n
m n m n m n m n
- Potenz:
a � a � a a � a / a ( a ) �
- Logarithmus: log( ab) � log a � logb
a n a
- …
n
log( ) �
log

210
Mengenlehre
Mengen und deren Operationen
B
Konzepte: Konzepte:
- Menge, leere Menge, Universalmenge A , B
- Elemente
a , b
- Operationen: Vereinigung, Vereinigung Durchschnitt, Durchschnitt 3 Differenzen, Differenzen Komplement
Komplement A ��
B , A ��
B , A ��
- kartesisches Produkt A� B
- Tupel
( a,
b)
- Elemente, Teilmenge, Gleichheit, Disjunktheit, Kardinalität a � A , A � B
- ÄÄquivalenz,
Potenzmenge P(A)
- Ordnung, Klassen, Schranken, Grenzen
- Abbildungen, Ein-, Einein-, Mehrdeutigkeit
- Reflexivität Reflexivität, Symmetrie, Symmetrie Transitivität
- Injektion, Surjektion, Bijektion
- Funktionen, Produkt, Inverse
- Reguläre Mengen und Operationen

211
Koordinaten
Parameterangabe für 2D und 3D Punkte
Koordinaten:
Koordinatenursprung und
Rechtssystem als Bezug
w
x , y
x , y , z
r , �
r , � , h
r , � , �
x , y , w
x , y , z ,
- kartesisch (2D):
- kartesisch:
- polar (2D):
- zylindrisch:
- sphärisch:
- homogen (2D):
- homogen:
Beliebige Punkte
als Bezug
1
�
V � tA � sB
t � s � 1
V � tA � sB
� rC
t � s � r � 1
V � tA � sB
� rC
� q qD t � s � r � q
- baryzentrisch:
* Linie:
* Fläche:
* Volumen

212
Trigonometrie
Arbeit mit Dreiecken
sin� � a / c cos� � b / c tan� � b / a 2 2 2
a � b � c
cos� � sin( � � 90�)
tan� � sin�
/ cos�
2
2
sin � � cos � �1
h � ab / c A � ab / 2
Rechtwinkliges Dreieck:
- Seitenverhältnisse:
- Winkelverhältnisse:
- Höhe, Fläche:
Gleichschenkliges Dreieck:
2
/
ch
A �
- Höhe, Fläche: � � 2
2
/
c
2
h � l �
h � 3l / 2
3 / 4
2
A � l
Gleichseitiges Dreieck:
- Höhe, Fläche:
2
/
Allgemeines Dreieck:
- Sinusregel:
a / sin�
� b / sin � � c / sin �
- KKosinusregel: i l a � b cos� � c cos ��
- Summenregel: sin( � � � ) � sin�
cos � � cos�
sin �
- Winkelsumme: � � � � � � 180�
- Umfang: g
U � a � b � c
- Fläche: A � ah / 2 A �
s(
s � a)(
s � b)(
s � c)
, s � U

213
Planimetrie
Arbeit mit ebenen geometrischen Figuren
Fläche:
2
U � 4a
A � a
U � 2a � 2b
A � ab
U � a � b � c � d A � ( a � b)
h / 2
U � 2 2a �� 2 b
A � ab bsin
i �
U � 2a � 2b
2
A � a / 2
U � 2a � 2b
A � ab
( �� � � � ���
2
2
2
n
( x � x ) � ( y � y ) A � � �y � y ���x � x �
i�1
(modn
) � xi
) � ( yi�1(modn
) � yi
) A � � y �
i�0
i yi�1(modn
) xi
xi�1(modn
)
n
��
i�0
2
��
2
A � �r
A � �ab
U � 2�r
1
1
2 2
x � y � r
2 2 2 2
x / a � y / b �
2 2 2 2
xx
/ a � y / b �
2
y � 2 px
- Quadrat:
- Rechteck:
- Trapez:
- Parallelogramm:
- Rhombus:
- Drachenviereck:
- Viereck:
U
- Polygon:
- Kreis
- Ellipse:
- Hyperbel:
- Parabel:
Verhältnisse:
- Strahlensätze an geschnittenen geschnittenen Parallelen: Parallelen:
- Winkelsätze am Kreis:
- Sehnen, Sekanten, Tangenten am Kreis:
- Goldner Schnitt: b � a �� 5 �1��
2
�y � y1�
�x �x1
� � m
�y � y1�
�x �x1
� � �y2 � y1�
�x2 �x1
�
ax � by � d � 0
x / a � y / b �1
n
y � mx �
Gerade:
- Definition:

214
Stereometrie
Arbeit mit räumlichen geometrischen Figuren
Körper:
A � 2( ab � ac � bc)
V � abc
2
3
A � 6a
V � a
A � 2G � M
V � Gh
A � 2�rh
2
V � �r
h
A � G � M
V � Gh / 3
2
2 2
A �� �� r ��
��
r r ��
h
2
V ��
r h h��
/ 3
3
/
4 3
V � �r
2
A � 4�r 1
1
�
�
2
2
0
2 2 2 2
x � y � z � r
2 2 2 2 2
x / a � y / b � z / c
2 22
2 2 2
x / a � y / b � z / c
2 2 2 2
x / a � y / b � 2cz
�
- Quader:
- Würfel:
- Prisma:
- Zylinder:
- Pyramide:
- Kegel:
- Polyeder:
- Kugel:
- Ellipsoid:
- Hyperboloid:
- Paraboloid:
� x1)((
y2z3
� y3z
2)
� ( y3z1
� y1z3
) � ( y1z
2 � y2z
)) �
� y1)((
z2x3
� z3x2
) � ( z3x1
� z1x3
) � ( z1x2
� z2x1
)) �
� z )(( x y � x y ) � ( x y � x y ) � ( x y � x y )) �
( x
1
z � mx � ny � o
ax � by � cx � d � 0
x
/ a � y / b � z / c �1
Ebene:
- Definition:
y
(
0
1
2
2
1
3
1
1
3
2
3
3
2
1
z
(

215
Interpolation
Stetige Überführung von Zahlen, Parametern, Punkten, Vektoren in andere
��
0
1
� 1�
� ��
�
� 1 2 1�
� p
� ��
�
�
� �
��
�
� �
��
� 1 � 2 1 p
� 2 2 0 p
� 1 0 0 p
�
2
Polynomiale Polynomiale Interpolation:
- linear:
- quadratisch:
- kubisch:
- allgemein ll i (nicht ( i h rekursiv): k i )
- allgemein (rekursiv):
(Bernstein-Polynome)
)
( t
n
i
B
i
p
n
�i�0 �
)
( t
p
�� �
�
1
1
�
�
n
i
�� �
�
n!
( n � i)!
i!
� � �
�
�
�
�
�n �1
� i
��1
1�
� p0
�
2
p � �t 1��
� � � � � p � t t
� 1 0�
� p1
�
��1 3 � 3 1�
� p0
�
� �
� ���
�
�
�
���
�
�
�
�
���
�
�
�
���
�
p0
3 2 3 � 6 3 0 p1
p � t t t 1 �
� 3 3 0 0 p2
��
1 0 0 0 0�
� p p3
�
n n i n�i
Bi
t t � t
i
�� �
�
�
�
�
n
( ) � ( 1 )
�
�
i
�� �
�
�
�
�
�
n
n�1
n�1
Bi
( t)
� ( 1�
t)
Bi
( t)
� tBi�1
( t)
� � �
�
�
�
�
�n
0
B ( ) 1
� i
0 t � B ( t)
� 0 für j � 0
n
j
n
i � 0,...,
�n
2
2 1 �
�cos ( t)
sin ( t)
�� � �
�n2
�
Trigonometrische Interpolation:
- translatorisch:
n �
- rotatorisch:
��
�
�
1
��
�
�
�
��
�
�
��
sin(( 1�
t)
� ) sin( t�
)
�
� sin( � ) sin( � )
�
2
v
v
v

216
Vektoralgebra
Arbeit mit Vektoren im 3D Raum (Spezialfall 2D)
p � xi � yj�
zk
p � � T
1
0
� �
2 2 2
p � x � y � z
T
op
p
p � x y z
� � �
pu
� 1
� �T cos� x � p x p cos� y � p y p cos�
z � p z p
p � 1 0 0 � �T � 0 1 0 p � 0
cz
cy
cx
Definition: Definition:
- Positionsvektoren:
- Richtungsvektoren:
- Betrag:
- Ri Richtung: h
- Einheitsvektor:
- Kartesische Vektoren:
- Multiplikation: � � T
� � � � p p cos�
2
1
pu � p p
p � p1
cos�
p s � � xs yx zs zs�
� �T p1
� p2
� x1 � x2
y1
� y2
z1
� z2
T
p1 �p 2 � x1
y1
z1
� x2
y2
z2
� x1x2
� y1y
2 � z1z
2 �
T � y1z
2 � z1y
2 �
�
�
� ��
�
� �
��
T � y1z
2 z1y
2
� y1
z1
x1
z1
x1
y1
�
p1
�p
2 � � �
� � z1x2
� x1z
2
� y2
z2
x2
z2
x2
y2
�
�x1
y2
� y1x2
( p �p
) �p
Manipulation:
- Normalisierung:
- Projektion:
- Multiplikation:
- Addition:
- Skalarprodukt:
- Vektorprodukt:
3
2
1
- Spatprodukt: p p
�p1 p2
sin�
�
3
p1 �p
2 �
( p �p
) �p
2
1
�
�
A
V
- Parallelogrammfläche:
- Parallelipedvolumen:

217
Berechnungen:
)
d
�
�n
p
p � p1
� t(
p2
� p1
p � a � tb
- Definition einer Gerade:
(Punkt, Parameter, Hesse)
0
( � p ) �n
�
p 1
0
( p � p1)
�((
p2
� p1)
� ( p3
� p1))
�
p � a � sb � tc
p �n � d
- Definition einer Ebene:
(Punkt, Parameter, Hesse)
1
p
p2 �
0
�
� ( 2 , n3
�p
0
b� ( p � a)
a � (( p � a ) �b
) b
b� ( a2
� a1)
( a2 � a1)
�(
b1
�b
2)
( b1
�b
2)
cos ( )
1 �
b1 �b
2
1
cos ( )
1
1 2 n
�
n �
cos ( )
( p � ( d � p �n)
�n
1 �
b �n
d � p �n
( p ( p )
a � ( d � ( n �a))
b
b1
�b 2 � 0 � ( a1
� a2
) �(
b1
�b
2)
� 0
p p0
� t n1
�n
2)
mit n1
�p
0 � d1
, n2
�p
0 � d
A � ( p p2 � p p1
) ��
( p p3
� p p1
) / 2
( p2
� p1)
� ( p3
� p1)
� 0
q � �2( n �p
� d)
n �n�n
- Abstand zweier Punkten:
- Abstand von Punkt und Gerade:
- Fußpunkt eines Punktes auf Gerade:
- Abstand zweier paralleler Geraden:
- Abstand zweier beliebiger Geraden:
- Winkel zweier Geraden:
- Winkel zweier Ebenen: Ebenen:
- Winkel von Gerade und Ebene:
- Abstand von Punkt und Ebene:
- Fußpunkt eines Punktes auf Ebene:
- Schnittpunkt von Gerade und Ebene:
- Schnittpunkt zweier Geraden:
- Schnittgerade zweier Ebenen:
- Dreiecksfläche:
- Kolinearität dreier Punkte:
- Reflexion von Punkt an Gerade:
n � 1 p cos�
� d
d
�p � n p cos�
�
n
Hessesche Normalform:
Richtungen- und Normalen sind in der Regel Einheitsvektoren!

218
Matrizenalgebra
Matrizen und deren Operationen
Definition: Definition:
�
1,
n
a
...
� ��
��
m , 1
m m,
n
a
j
�
i
� ��
� a1,
1 ...
A(
m,
n)
� ... ...
n � 1
��
am
...
m � 1
m � n
ai, j � 0 für i � j
a i , j � 1 für f i � j , a i i,
j � 0 für f i � j
ai, j � const für i � j , ai,
j � 0 für
ai , j � 0 für i,
j
ai , j a j,
i für i , j
� j j
ai, j � 0 für i � j , ai,
j � 0 für i � j
det( A)
� 0
det( A) � 0
�1 T
A � A
�1
A � A � I
- Matrix allgemein:
- Spaltenmatrix:
p
- Zeilenmatrix:
- quadratische Matrix:
- Diagonalmatrix:
- Identitätsmatrix I:
- Skalare Matrix:
- Nullmatrix 0:
- symmetrische Matrix:
- untere, obere Dreiecksmatrix:
- reguläre (invertierbare) Matrix:
- singuläre (nicht invertierbare) Matrix:
- orthogonale Matrix: Matrix:
- inverse Matrix:

219
Operationen:
�� a j,
i ai,
j m,
n ��
m,
n � �c i,
j ci,
j � ai,
j bi,
j �
�� b bi,
j b bi,
j a ai
s s��
�ci , j | ci
j � aib
j �
n
ci
| ci
� ai
� � ��
a
j i jb
j�1
, j
l
, n � ci,
j | ci,
j � ai
� j � �
A , � A � | � A
, m
n
n
T
m
- Transponierung:
, � A � B | �
m n m,
n
m , n �� A Am,
n s ��
| ��
, j
C
- Addition, Subtraktion:
B
- Multiplikation Multiplikation mit Skalar:
� �m � j � 1 j
i i�
1
m,
n
� a b �
T
� am
�b
n � ,
m,
n
C
- Multiplikation zweier Vektoren:
� A �b
� b
n
, n
m
m
c
- Multiplikation von Matrix und Vektor:
�1
j
,
i
j
,
k
, k
i
�1
� A �B
b
k
l
, l
1
m
, n
m
C
- Multiplikation:
�1
n
A
�
A
�
n
A
,
A
�
A
,
E
�
0
A
- Potenz:
- Axiome: Kommutativität, Assoziativität, Distributivität
- Minorisierung: B 1 � min A Löschen der i-ten Zeile und j-ten Spalte einer Matrix
, m�1
i,
j � m m �
�� �� ��
�� �� ��
��
i�1
i�
j
n � cof �A m,
n � � �ci , j | ci,
j � ( �1)
det�min
i,
j �A m,
n ���
� � � � ��T
m � adj j �A m , n � �coff �A m , n ��
�1
�1
i�
j
m � adj �A m,
m � det�A m,
m � � ai,
j | ai,
j � ( �1)
det�min
i,
j �A m,
m ��
det�A
m,
m �
m �
,
m i�
j
- Determinante: det A m,
m ��
A m,
m ��
a ai,
j ( � 1 ) det min i,
j A m,
m für beliebige Spalte j
,
m
C
- Kofaktormatrix:
B �
- Adjungierte Matrix:
� �
n ,
�1
m,
A
- Inverse Matrix:
B
�1
X � B A � A �
- Division: