Die einzelnen Definitionen hab ich in Pascalcode geschrieben. Einfach damit es übersichtlicher ist. Es ist also kein Code

Also ich versuch mich grad daran ein Flugzeug mit Quaternionen zu rotieren.

Ich habe auch ein sehr gutes Buch "Mathematics for Computergraphics" gefunden, welche diese sehr gut, meiner Meinung nach, erklärt. Naja ich dachte ich hätte sie verstanden, aber jetzt bieten sie mir doch Kopfzerbrechen.


Und zwar hab ich mich ziemlich nach dem Buch gerichtet mein Programm zu implementieren.

Da steht folgendes:

1. Ein Quaternion hat die Form:

2. Konvertierung eines Punktes p zu einem Quaternion q:

3. Eine Rotationsachse wird in einem Einheitsvektor u gespeichert. (zB x-Achse: u= (1,0,0))

4. Ein Transformationsquaternion ist definiert als

5. Ein inverser Transformationsquaternion ist definiert als

6. Man kann die Drehungen pitch (Drehung um die x-Achse), yaw(Drehung um die y-Achse), roll(Drehung um die z-Achse) in drei verschiedene Quaternionen
zusammenfassen:


7. Diese 3 Quaternionen kann man wieder zu einer multiplizieren.



Um nun einen Punkt zu tranformieren, bzw zu rotieren geht man wie folgt vor:

8. Multipliziere den Tranformationsquaternion mit dem zu rotierenden Punkt und schließlich mit der inversen Transformationsquaternion, um den transformierten Punkt p' zu erhalten. Das sieht wie folgt aus:



In dem oben verlinkten Buch, wird ab Seite 90 nochmal alles gut erklärt. Auch das Beispiel auf Seite 96 ist super. Falls ich was falsch verstanden hab, dann wäre ich für jede Berichtigung dankbar.

Also soviel zur Theorie.

Mein Problem ist die Implementation. Und zwar möchte ich mein Flugzeug durch die Tasten pitchen, rollen und yaw'n, falls man das so sagen kann .

Als erstes hab ich mir ne Klasse Quaternion.cpp erstellt:



Dann meine Flugzeugklasse.



in der main




Die Sache ist mein Objekt rührt sich kein Stück
Also ich glaube mein Hauptproblem liegt darin, dass ich mit Quadriken arbeite und deshalb auf die einzelnen Vertices nicht zugreifen kann.
Ich hatte im Nehe Tutorial zur Implementierung mit Quaternionen gelesen, dass der Tranformationsvektor immer in der Matrix an Stelle 8,9,10 gespeichert ist.
Nehe - Camera Class Quaternionen (in Kästchen 5)
Ich berechne diese 3 Werte in void Quaternion::dir_vector(float pos[]) und übergebe sie dann in meiner Flugzeugklasse an einen Vektor, den ich dann an glTranslate übergebe.

Also irgendwo da liegt grad der Wurm begraben.

Ich hoffe ich hab mein Problem klar genug beschrieben und euch nicht mit dem Riesenpost erschlagen.

Falls ihr irgendwo mein Text zu unklar ist, einfach fragen.
Ich starre schon so lange auf den Code und hab langsam keine Ideen mehr.

Ich wäre für eure Hilfe sehr sehr sehr dankbar.

Danke euch

Liebe Grüße

Lena

Ok, ich habe deinen Post nicht zu 100% gelesen, aber hier mal ein paar Hinweise

• Mit yaw/pitch/roll zu arbeiten ist nicht so sonderlich sinnvoll. Modifiziere das Quaternion direkt indem du ein anderes daran multiplizierst.
• Wo wird den in deinem Code die Rotation vom Quaternion an OpenGL übergeben?
• Eine Methode die ein Quaterion in eine Matrix umwandelt ist ganz hilfreich. Einfach mal Copy&Paste aus meinem Code:
  
  Code:
  1.  
  2. // bei mir ist a = s, b = x, c =  y und d = z
  3. // möglicherweise musst du die Matrix transponieren
  4. template<class T> inline CMatrix44<T> CQuaternion4<T>::getMatrix44() const
  5. {
  6.     return CMatrix44<T>( (a*a + b*b - c*c - d*d), 2*(c*b+a*d)            , 2*(d*b-a*c)            , 0.0f,
  7.                          2*(b*c-a*d)            , (a*a - b*b + c*c - d*d), 2*(d*c+a*b)            , 0.0f,
  8.                          2*(b*d+a*c)            , 2*(c*d-a*b)            , (a*a - b*b - c*c + d*d), 0.0f,
  9.                          0.0f                   , 0.0f                   , 0.0f                   , 1.0f  );
  10. }
  11.  
  12. // wie getMatrix44() nur eben eine 3x3-Matrix
  13. template<class T> inline CMatrix33<T> CQuaternion4<T>::getMatrix33() const
  14. {
  15.     return CMatrix33<T>( (a*a + b*b - c*c - d*d), 2*(c*b+a*d)            , 2*(d*b-a*c)            ,
  16.                          2*(b*c-a*d)            , (a*a - b*b + c*c - d*d), 2*(d*c+a*b)            ,
  17.                          2*(b*d+a*c)            , 2*(c*d-a*b)            , (a*a - b*b - c*c + d*d)  );
  18. }
  19.  
  20. // einen Punkt mittels dem Quaternion rotieren
  21. template<class T> inline CVector3<T> CQuaternion4<T>::rotate(const CVector3<T> v) const
  22. {
  23.     return v * getMatrix33();
  24. }
  
  Diese Matrix kannst du dann an OpenGL übergeben.
• Mit Quaternationen alleine lassen sich keine Translationen darstellen!
• Verwende ein Tupel aus einem Quaternion und einem Translationsvektor. Ich nenne sowas "Frame". Man kann solche Frames dann auch miteinander multiplizieren, sodass man sie wie gewöhnliche Matrizen behandeln kann, mit dem Unterschied das z.B. das invertieren wesentlich leichter ist! Ich verweise da mal auf dieses Paper, Abschnitt III. Auch hier mal ein wenig Copy&Paste:
  
  Code:
  1.  
  2. // ein Frame besteht bei mir aus einem CVector3<T> p und einem CQuaternion4<T> q
  3.  
  4. // zwei Frames multiplizieren (als wären es Matrizen...)
  5. template<class T> inline CFrame7<T> CFrame7<T>::operator*(const CFrame7<T>& f) const
  6. {
  7.     return CFrame7<T>(p + q.rotate(f.p), q * f.q);
  8. }
  9.  
  10. // Frame in Matrix umwandeln
  11. template<class T> inline CMatrix44<T> CFrame7<T>::getMatrix() const
  12. {
  13.     // Quaternion-Matrix holen und Translations-Teil überschreiben
  14.     return q.getMatrix44().setW(p);
  15. }
  16.  
  17. // inverse Abbildung berechnen
  18. template<class T> inline CFrame7<T> CFrame7<T>::getInverse() const
  19. {
  20.     const CQuaternion4<T>& c = q.conjugated();
  21.     return CFrame7<T>(c.rotate(-p), c);
  22. }
  23.  
  24.  
  
  
  

_________________
Yeah!

Hallo Lena,

willkommen im Forum.

OK, Coolcat ist mir zuvor gekommen. Mein Post ist nicht so toll wie seiner. Aber da ich ihn nunmal schon geschrieben habe, stelle ich das Ganze mal rein.

Hmm, für mich sieht das so aus, als ob Du mit riesig viel Arbeit den Vektor "newPos" errechnest. Diesen steckst Du dann in die OpenGL-Funktion "glTranslatef". Das kann deshalb nicht funktionieren, denn Du möchtest eine Rotation erreichen, aber dann verschiebst Du das ganze Gebilde nur. Der Unterschied ist leicht erklärt: stell Dir mal vor, wir beide stehen uns gegenüber, das soll heißen, Deine Nase zeigt in meine Richtung. Dann drehst Du Dich (von Dir aus geshen) um 90 Grad nach rechts. Ich sehe Dich jetzt im Profil.

Dein Programm würde aber Deine Nasenspitze nicht rotieren, sondern nur verschieben (also nicht nur Deine Nasenspitze, sondern Dich als Ganzes), weil Du glTranslate benutzt. Wenn der errechnete Vertex stimmt, verschiebt er Dich ein Stück nach hinten und eine Stück nach rechts (von Dir aus gesehen). Du schaust aber nach wie vor in die gleiche Richtung.

Immer vorausgesetzt das Quaternionen-Ergebnis ist prizipiell richtig - was ich nicht nachgerechnet habe.

Was ich mit dieser langen Vorrede sagen will: Der Ansatz ist falsch, so wirst Du keine Rotation erreichen.

Ich würde einen Step-by-Step-Ansatz vorschlagen:
1. Zunächste eine einfache OpenGL-Anwendung zum Funktionieren bringen, und zwar mit glRotate anstatt des Quaternions.
2. Dann eine Lösung mit einem Quaternion verwirklichen, das nur um *eine* Achse dreht.
3. Wenn das mal erreicht ist, schließlich die Quaternionen-Multiplikation dazunehmen.

Hinweis1: wenn man keine Shader benutzt, ist es nicht möglich, ein Quaternion in einer OpenGL-Anwendung zu benutzen. Die einzige Möglichkeit, die mir einfällt: das Quaternion in eine Matrix umwandeln und als Input für glMultMatrix benutzen. Ist aber das Gleiche, was Coolcat schon gesagt hat.

Hinweis2: die Matrix, die dabei erzeugt wird, ist als Rotations-Input anzusehen, und muss sich genauso verhalten wie glRotatef.

Viele Grüße
Traude

Ähm, genau....Shader braucht man eigentlich nicht...

_________________
Yeah!

Vielen lieben Dank Coolcat und Traude.

Also gut ich wollte eigentlich so gut wie möglich vermeiden mit den Matrizen zu arbeiten, aber jetzt muss ich wohl in den sauren Apfel beißen.

Nun Coolcat ich hab mir deinen Code angeschaut. Ich bin leider in Templateklassen nicht so bewandert. Ich kann sie zwar halbwegs lesen, aber selber nutze ich sie nicht so gern, weil das ist irgendwie immer voll das Durcheinader und ich krieg immer nur Fehler.

Aber gut deinen Code habe ich, denke ich, halbwegs verstanden und kann ihn wohl in etwas, für mich, einfachere Strukturen umwandeln.

Ich hab allerdings n paar Fragen zu deinem Code.

Bitte nicht killen, wenn ich völligen Blödsinn schreibe.

1. Also, wenn ich das richtig verstanden habe bedeuted die Funktion , dass ich aus der Matrix44 drei Werte entnehme und im Vector überschreibe.
Ist das richtig, dass es die Werte aus der dritten Zeile sind, also:



2. Die Funktion erstellt aus einem Quaternion den Quaternion

3. Bei der Funktion rotieren wird wohl ein Punkt(bzw. Vektor) übergeben, welcher zum Objekt gehört. Da ist aber mein Problem, dass ich keine konkreten Punkte übergeben kann, da mein Objekt aus Quadriken besteht. Und ich nicht auf die Punkte zugreifen kann.

Also falls ihr jetzt nur noch mit dem Kopf schüttelt, verweise ich auf den Satz aus der Sesamstraße: Wer nicht fragt, bleibt dumm.

Dank euch

Liebe Grüße

Lena

Die Grafikkarte und OpenGL arbeiten nun mal mit Matrizen.


Das "template<class T>" kannst du auch einfach weglassen. Auch ein "<T>" kannst du ignorieren. Wenn irgendwo der Datentyp "T" benutzt wird kannst du einfach "float" annehmen. "inline" und "const Datentyp&" sind immer nur Optimierungen, kann man auch weglassen, also einfach "Datentyp" schreiben.

zu 1:
Nein. Der gegebene Vektor p = (x,y,z) wird in der Matrix an die Stellen _41, _42 und _43 geschrieben. Es handelt sich um die 4. Zeile der Matrix. In diesen Zellen befindet sich die Translation der Matrix. Anschließend wird von setW eine Referenz auf die Matrix zurückgegeben, was die Handhabung vereinfacht, da man so z.B. mehrere set*()-Aufrufe verketten kann. Die Methode setW ist wie folgt definiert:


Die 4x4-Matrix ist bei mir übrigens so definiert. Die Werte stehen in dieser Reihenfolge im Speicher und werden daher auch so an OpenGL übergeben wenn man glMultMatrixf(&matrix._11); aufruft.


zu 2:
korrekt. Hier der Code:


zu 3:

Wenn ich mich nicht irre kannst du die Quadrik Q mit einer Transformationsmatrix M transformieren und so die gewünschte Quadrik Q' erhalten. Eine Quadrik ist ja definiert als:

Wahrscheinlich musst du einfach x vorher transformieren, also wahrscheinlich irgendwie so etwas:

Möglicherweise musst du M auch invertieren (*), müsste man mal länger drüber nachdenken.

(*) was ja ganz leicht geht, wenn deine Matrix aus einem Quaternion erzeugt wird...

_________________
Yeah!

Ich arbeite nicht mit Quadriken, aber ich wette, Du musst nur die die Transformation setzen bevor Du die Quadrik zeichnest, entweder mit den OpenGL-Befehlen glTranslate/glRotate oder mit glMultMatrix (vorher glLoadIdentity nicht vergessen). Das würde ich außerst merkwürdig finden, wenn man hier noch irgendwas invertieren müsste. Man muss auch gar nicht auf die einzelnen Punkte zugreifen, denn für die Transformation ist OpenGL zuständig. Du könntest die einzelnen Punkte - wenn Du sie hättest - selber transformieren. Aber es ist eine *langsame* Methode.

Falls die Umwandlung QuaternionToMatrix in Deinem Buch nicht drin ist, hier kannst Du fündig werden:
http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/index.htm.

Das ist übrigens eine außerst nützliche Website, ein zweiter Blick drauf lohnt sich.

Genau.

Viele Grüße,
Traude