Matrix: Unterschied zwischen den Versionen

Version vom 13. Oktober 2006, 15:37 Uhr

Hinweis: Dieser Artikel wird gerade Offline bearbeitet! Bitte haben Sie etwas Geduld und nehmen Sie keine Änderungen vor, bis der Artikel hochgeladen wurde. (weitere Artikel)

Matrix / Matrizen

Übersicht

Eine Matrix ist im wesentlichen nichts anderes als das, was man in der Programmierung als zwei dimensionales Array kennt. Dabei beschreibt eine Matrix eine lineare Abbildung, was als Information bei Rechnungen sehr wichtig ist.

Wichtig: Für den Einstieg in OpenGl ist ein tiefergehendes Verständnis von Matrizen noch nicht notwendig um bereits interessante Ergebnisse zu erzielen. Es genügt am Anfang zu wissen, daß man damit Verscheibungen, Drehungen und Streckungen beschreiben kann und das die Reihenfolge der Befehle zum Manipulieren der Matrix wichtig ist. Wer also noch seine ersten erfahrungen mit OpenGl macht, kann sich zuerst in unseren Tutorias informieren und erst anschließend hier wieder vorbeischauen.

Anmerkung: Wir wollen mit den Definitionen hier nur soweit gehen, wie es für ein Verständnis von OpenGl Geometrie wichtig ist. In der Linearen Algebra werden einige der hier gegebenen Begriffe deutlich genauer und häufig auch abstrakter betrachtet. Dies würde jedoch unseren kleinen Rahmen deutlich sprengen.

Definition

Matrizen sind Abbildungen auf Vektorräumen ganzzahliger Dimension. Für alle weiteren betrachtungen seien also die Zahlen n und m aus dem Bereich {1,2,3,4,5,... }, also den natürlichen Zahlen ohne Null, fest vorgegeben.

Rⁿ Vektorräume

Um Matrizen definieren zu können, müssen wir zuerst Vektorräume definieren. Ein Vektorraum (V,*,+) ist eine Menge Vektoren V zusammen mit einer Skalar-Multiplikation * und einer Addition auf Vektoren, auf denen man vernünftig rechnen kann.

Hat man also zwei Vektoren v₁ und v₂, so kann man diesen eindeutig eine Summe zuordnen:

v3 = v1 + v2 .

Ausserdem kann man sie mit einem Skalar c aus den reelen Zahlen strecken:

v4 = c*v1 .

Beispiel: Der Standardvektorraum Rⁿ: Ein Vektor v aus dem Rⁿ besteht aus n reelen Zahlen ( seinen Komponenten ), deren Reihenfolge wichtig ist. Man kann also v auch in Form seiner Komponenten schreiben:

Häufig wird kein Unterschied dahingehend gemacht, ob der Vektor als Zeile oder als Spalte geschrieben wird. Bei der später definierten Matrixmultiplikation wird dies jedoch durchaus interessant, wir wollen uns also erstmal darauf beschränken, daß auch die Schreibweise

v=(v1,...,vn)

für unseren Vektor v eine legitime Schreibweise darstellt.

Um unseren Vektorraum zu vervollständigen brauchen wir nach definition nun auch noch eine Addition und eine (Skalar-)Multiplikation. Die Addition geschieht komponentenweise. Hat man also einen zweiten Vektor b = v=(b₁,...,b_n), so ist die Addition definiert durch:

Die Multiplikation eines Vektors v mit einem reellen Faktor λ entspricht einer Streckung des Vektors um λ, was durch Multiplikation aller Komponenten von v mit λ erreicht wird:

Es ergeben sich die von den normalen reelen Zahlen bekannten Rechenregeln:

λ*( v + b ) = λ*v + λ*b , 

d.h. man kann Skalare einfach aus Klammern ausmultiplizieren oder wieder hineinziehen. Man beachte aber, daß dei Multiplikation von Vektoren nicht definiert ist. Siehe auch Vektorprodukt, Standard Skalarprodukt

Ist unser n gerade die Zahl 3 bzw. 2, so kann man durch den Rⁿ gerade den 3-Dimensionalen bzw. 2-Dimensionalen Raum darstellen. Vektoren kann man dann sogar zeichnen und bekommt eine bildliche Vorstellung. Vektoren werden zu einer Darstellung von Pfeilen, die eine Richtung beschreiben oder ausgehend vom Nullpunkt des Koordinatensystems einen Punkt definieren:

Lineare Abbildungen auf dem Rⁿ in den R^m

Weiter kann man Abbildungen f, die als Parameter Vektoren des Rⁿ annehmen und diese in den R^m abbilden, definieren. Insbesondere kann man Abbildungen definieren, die linear sind, d.h. daß f folgende Eigenschaften erfüllt:

und zwar für alle a,b aus Rⁿ und alle λ aus den reellen Zahlen R. Interessant ist, daß solche Abbildungen also die Rechenregeln aus unserer Vektorraumdefinition erhalten. Sehr wichtig ist jedoch: Solche Abbildungen existieren. Die einfachste ist die, die alle Vektoren aus Rⁿ auf die 0 abbildet ( die 0 ist der Vektor des R^m, in dem alle Komponenten gleich 0 ist. ). Tatsächlich gibt es deutlich mehr dieser Abbildungen und alle lassen sich als Matrizen darstellen. Und umgekehrt: Matrizen stellen lineare Abbildungen dar.

mxn-Matrizen und ihre Anwendung auf Vektoren

Wie bereits angesprochen, sind Matrizen also 2 Dimensionale Felder aus rellen Zahlen:

Die a_ij werden dann die Koeffizienten der Matrix genannt. Nun wollen wir das Anwenden der Matrix A aus R^mxn auf einen Vektor x definieren:

Beispiel:

Am Bild erkennt man auch, warum die Matrix-Vektor Multiplikation ( " Anwendung " ) auch als Zeile mal Spalte bezeichnet wird, denn die Koeffizienten einer Zeile der Matrix werden der Reihe nach mit den Koeffizienten der "Spalte" des Vektors multipliziert. Dieses Verfahren kann man erweitern, indem man Vektoren als Matrizen interpretiert, die nur eine Spalte haben. Schreibt man also mehrere Vektoren nebeneinander kann man für jede dieser Spalten die Matrix darauf anwenden:

mxn-n,r-Matrix-Matrix Multiplikation

Man hat also eine mxn-Matrix A und eine nxr-Matrix B, die man Spaltenweise als Vektoren versteht:

Bei der Multiplikation von A mit B, wird dann einfach A auf die Vektoren b_i angewendet.

Beispiel:

Eigenschaften

Diese Multiplikation hat eine Reihe von Eigenschaften:

• Versteht man die Matrizen A,B als lineare Abbildungen auf Vektoren x aus dem Rⁿ und y aus R^r, also f(x) = A*x und g(y) = B*y und ist A eine mxn-Matrix, sowie B eine nxr Matrix, dann ist die Abbildung f(g(y)) eine Lineare Abbildung, die beschrieben ist durch

f(g(y)) = A*B*y .

• Daraus ergibt sich, da schon die Definitions-Vektorräume verschieden sind, daß in den meisten Fällen nicht gilt: A*B=B*A . Wer sich dies genauer überlegt, stellt fest, daß das 2. Produkt nur dann definiert ist, wenn A und B beides nxn-Matrizen sind. Aber selbst in diesem Fall ist es im Allgemeinen ein Unterschied, ob ich A*B oder B*A rechne ( Das führt schließlich zu der Tatsache, warum man in OpenGl aufpassen muss, ob man zuerst Rotiert und dann verschiebt oder umgekehrt: Diese Operationen werden durch Matrizenmultiplikationen implementiert! ).

• Matrizen stellen Lineare Abbildungen dar, es gilt also:

A*(x+x') = A*x + A*x'
A*(B+C) = A*B + A*C 
A*(λ*x) = λ*A*x

• Man nennt eine Gleichung A*x = b ein Lineares Gleichungssystem, wenn A und b bekannt und x gesucht ist.

Siehe Auch

Es gibt noch eine Menge weiterer Eigenschaften, und Funktionen, die in Bezug auf Matrizen höchst interessant sind:

Matrix_Transposition, Matrix_Inversion, Determinante

Matrizen in OpenGl

Die drei OpenGL Matrizen

In OpenGL gibt es drei 4x4-Matrizen welche alle mit Hilfe von glTranslate, glScale, glRotate,glMultMatrix,glLoadMatrix und glLoadIdentity bearbeitet werden können. Welche Matrix von diesen Funktionen beeinfusst wird, kann durch glMatrixMode gesteuert werden.

Die 3 Matrizen sind:

GL_PERSPECTIVE

Sollte nur für die Festlegung der Perspektive genutzt werden.

GL_MODELVIEW

Legt Position und Größe des zu zeichnenden Primitiven fest

GL_TEXTURE

Beinhaltet Informationen wie Texturen dargestellt werden.

Noch mehr Informationen zu den Matrizen und was sie bewirken gibts im Tutorial Matrix2.

Aufbau einer OpenGL-Matrix

Möchte man mit OpenGL an einer bestimmten Stelle etwas zeichnen, so kann man mit Hilfe von glTranslate und glRotate die Modelview-Matrix so manipulieren, dass etwa der mit glVertex übergebene Eckpunkt (0/0/0) im Weltkoordinaten System nicht mehr in der Mitte liegt. Alle Punkte erscheinen scheinbar in einen zweiten Koordinaten System welches etwas verdreht, vegrößert oder verrutsch liegen kann.

Dieses zweite Koordinaten-System wird durch eine 4x4-Matrix, also einem zwei dimensionenlen Array mit vier Spalten und Zeilen, beschrieben.

Damit besser verstanden werden kann wie dies funktioniert, wird die Funktionsweise erstmal anhand eines zwei dimensionalen Koordinaten System demonstiert.

Möchte man in einem einfachen 2D Koordiaten-System den Punkt (X/Y) antragen, so hängt man X mal den Vektor der X-Achse aneinander, und Y mal den Vektor der Y-Achse.

Um die Lage und Größe eines Koordinatensystems zu beschreiben werden also einmal die Vektoren benötiget die 1 Längen Einheit meiner Achsen beschreiben, sowie ein Vektor der ihre Position in Anhängigkeit zum übergeordneten Koordinatensystems beschreibt.

Wie bereits bemerkt, müssten die Matrizen eigentlich 3x3-Matrizen sein, da sie ja auf dem 3D-Raum operieren sollen. Damit lassen sich jedoch keine Verschiebungen beschreiben, weswegen man bei der übergabe von Vertexdaten mit glVertex im Hintergrund eine 4. Koordinate w neben (x,y,z) einführt. Diese hat wenn nicht explizit über glVertex4x angegeben, den Wert 1.0 und so lassen sich mit 4x4 Matrizen auch Verschiebungen beschreiben:

So wirkt jede Zeile der OpenGl-Matrix auf genau die entsprechende Koordinate des Vertex nach der Multiplikation mit einem Vertex (x,y,z,1). Ist die letzte Zeile der Matrix (0,0,0,1), hat also die Matrix die Form:

Dann beschreibt die letzte Spalte der Matrix gerade die Verschiebung unseres Vertices, wie man mit der oben definierten Anwendung einer Matrix auf einen Vektor leicht überprüft. Am Ende wird die w-Koordinate, sofern sie 1 ist wieder verworfen - was sie auch bleibt, denn die letzte Zeile der OpenGl Matrix ist gerade so gewählt, daß dies sichergestellt ist. Nur bei der endgültigen Darstellung auf den Monitor kommt der W-Koordinate noch eine weitere Bedeutung zu, weshalb Projektionsmatrizen ( erzeugt durch glOrtho, glFrustum, ... )

sich an diese Regel nicht halten. 

Folgendes Format könnte man also nutzen, um eine Matrix mit glGetFloatv auszulesen oder mit glLoadMatrix zu setzen.

TVektor = record X,Y,Z,W:glFloat end;
TMatrix = array[(mat_XAchse,mat_YAchse,mat_ZAchse,mat_Position)]of TVektor;
PMatrix = ^TMatrix;

Man beachte dabei, daß OpenGl Matrizen Spaltenweise im Speicher ablegt. Siehe dazu auch: glMultMatrix

Zum leichteren Verständnis

Dieser Abschnitt ist nicht für fortgeschrittene 3D Entwickler gedacht, sollte aber Anfängern die immer noch nicht wissen, was Matrizen eigentlich in OpenGL machen einen leichteren Einblick verschaffen.

Um sich Matrizen in OpenGL leichter vorzustellen, kann man folgendes Bild benutzen:

• Die 3D-Welt ist in einer Art Glaskasten abgelegt in dem es keine Physik gibt (Dinge können in der Luft schweben u.ä.).
• Matrizen sind Maschinen/Greifarme.
• Matrizen sind die einzige Möglichkeit in den Glaskasten hinein zu greifen.

Wie wir weiter oben bereits gelernt haben sind Matrizen ja eigentlich Tabellen mit Zahlen. Diese Zahlen sind die Stellschrauben an unseren "Greifarmen". Mit diesen Stellschrauben können wir die Greifarme im Glaskasten positionieren. Durch den OpenGL-Befehl glMatrixMode können wir auswählen welchen der beiden Arme wir gerade steuern.

ModelView - Der Objektmanipulator

Wird diese Matrix auf ein Objekt angewendet, ändert sich je nach Einstellung der Matrix dessen Position, Ausrichtung, Größe usw. (Man kann sogar den kompletten Glaskasten damit verschieben.) (Beispiel: Wirft man einen Würfel in eine Drehungsmatrix, kommt am Ende ein gedrehter Würfel raus.)

PerspectivMatrix - Die Kameralinse

Diese Maschine ist nur für die Ausgabe zuständig. Man kann über die Stellschrauben einstellen, welche Art der Projektion (Parallel-, Perspektivisch-,...), und wie nah und wie weit Objekte maximal von der Kamera entfernt sein dürfen, um sichtbar zu sein.

Wer nun auf den Geschmack gekommen ist und mittels glLoadMatrix mal selber die Stellschrauben einer der beiden Matrizen ändern möchte, der sollte sich das sehr gute Mathe Script zum Thema Computer Geometrie einmal ansehen (siehe Links). Das eben vermittelte Bild mag zwar helfen. Die Theorie muss aber verstanden werden um damit arbeiten zu können.

Siehe auch

glMatrixMode, glGet, glLoadIdentity, glLoadMatrix, glTranslate, glRotate, glScale, Quaternionen

Links

• Tutorial: Nachsitzen
• Recht umfangreiches, gut verständliches Script zum Thema "Computer Geometrie" (PDF)