Hallo Kai,
Mit Deinem Prg hast Du nun meine Rotationsreihenfolge „10x,
45z, -90y, 60z, 90x, -20x“ durchgeführt und durch
Multiplikation und Eulerdecomposing die drei Alternativwerte
„THETA=-176.338, PHI=-35.035, PSI=-138.408“, also „-176.338x,
-35.035y, -138.408z“ erhalten. Ich habe es nach Deinen Angaben
implementiert und bekomme schon andere Werte raus:
Hmmmmm …
Okay, die Werte sind ja auch nicht eindeutig, Transformationen
sind ja auch nicht eindeutig. Könnte man also hinnehmen…
Es ist jedoch so, dass wenn ich einen Punkt p(1,2,3) einmal
mit der ersten Rot.Folge transformiere und ein anderes mal den
Punkt mit den Alternativwerten transformiere, der Punkt eine
unterschiedliche Position einnimmt:
…
Ich glaube halt, dass man per Faktorisierung von der Matrix
nur dann korrekte Werte bekommt, wenn bei der Rotation stets
eine feste Reihenfolge der Rotationsrichtungen benutzt wird.
also Rges = Rx*Ry*Rz, zum Beispiel. Sowas wie ich angegeben
habe - mit einer willkürlichen Reihenfolge - scheint nicht zu
klappen, oder?
Oh mann, ich hoffe, dass kam jetzt verständlich rüber…
Ich habe, denke ich, Deinen Gedanken verstanden.
Es stimmt, dass die Reihenfolge der „naiven“
Rotationen *nicht egal* ist bezüglich der
Endkoordinate des rotierten Punktes - aber
bezüglich der Eulerzerlegung sollte das
egal sein, da in meiner Rotationsmatrix-
schreibweise *diese* Matrix eben den Aus-
gangs-Punkt letztlich eindeutig in den Endpunkt
transformiert *und* ja die Eulerzerlegung einfach
nur diese Matrix auswertet.
Hast Du noch eine Idee oder klappt das bei Dir etwa und ich
habe falsch gecodet?
Ob Du falsch programmiert hast, kannst Du relativ
einfach bestimmen, in dem Du einen Fall durchlaufen
lässt, dessen Resultat Dir bekannt ist.
Beispiel: man nehme einen Punkt p{x=0,y=0,z=2}
und rotiere ihn 8x um 45° um die x-Achse v[1,0,0].
Da weiss man an jedem Punkt, wie die Koordinaten
aussehen müssen und wie die Eulerwinkel sein
müssen.
Ich hab das mal eben probiert und erhalte folgende
Ausgabe (Ausgabe der Punktkoordinaten rechts):
THETA=0.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=0.000, Z=2.000]
THETA=45.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=1.414, Z=1.414]
THETA=90.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=2.000, Z=0.000]
THETA=135.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=1.414, Z=-1.414]
THETA=180.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=0.000, Z=-2.000]
THETA=-135.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=-1.414, Z=-1.414]
THETA=-90.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=-2.000, Z=-0.000]
THETA=-45.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=-1.414, Z=1.414]
THETA=-0.000, PHI=0.000, PSI=0.000 POS=[X=0.000, Y=-0.000, Z=2.000]
d.h., ich komme sowohl wieder bei der
Koordinate [0,0,2] als auch bei den
Eulerkomponenten (0,0,0) wieder an. Somit
besteht der begründete Vorverdacht, dass
meine Routinen richtig rechnen 
Hier die angepasste Ausgabefunktion:
void **eulershowplus** (char desc[], VEC3 eu, VEC3 point)
{
printf("%s: THETA=%.3f, PHI=%.3f, PSI=%.3f\tPOS=[X=%.3f, Y=%.3f, Z=%.3f]\n",
desc,
rad2deg(eu[THETA]), rad2deg(eu[PHI]), rad2deg(eu[PSI]),
point[X], point[Y], point[Z]);
}
und die Schleife zur 45°-Schritt-Rotation:
void more\_rotations()
{
MAT3 mat, mresult;
VEC3 point = { 0, 0, 2 }; // dieser Punkt wird rotiert
VEC3 x\_axis = { 1, 0, 0 }; // um die X-Achse
int n = 0; // Zaehler 0..8
identity( **mresult** ); // verkettete Rotationen
setrotmatrix( mat, x\_axis, deg2rad(45) ); // \*eine\* Rotation \*um\* 45°
do {
VEC3 eu;
eulerdecompose(eu, **mresult** ); // aktuelle (verkettete)
**eulershowplus** ("", eu, point); // Matrix zerlegen \*und\*
// gedrehte Punktkoordinaten
matmult( **mresult** , mat); // und verketten
// fuer naechsten Durchlauf
rotate(point, mat); // naechste Rotation ausfuehren
} while (n++Achtung: die Rotation wird \*nur\* mit der
unveränderten Matrix _mat_(R=45°) durchgeführt,
die Matrix _mresult_ dient nur der sukzessiven
Verkettung, um die Eulerzerlegung machen zu können.
Probier doch mal, was Deine Routine
im "bekannten Fall" liefert.
Grüße
CMБ
