Koordinaten Transformation?

  • VB.NET

Es gibt 12 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Koordinaten Transformation?

    Hallo zusammen,

    ich habe es hin bekommen die Punktkoordinaten eines Würfel anhand von Roll, Pitch und Yaw Werten neu zu berechnen.
    Ich habe das mit einer Rotationsmatrix gelöst.
    Vielen Dank noch mal für die Unterstützung hier.

    Jetzt möchte ich das Ganze aber noch etwas verbessern.
    Ich möchte das der Würfel mit seiner Ausgangsposition beginnt die Roll, Pitch und Yaw Rotationen zu übernehmen.
    Aber wie stelle ich das am besten an?

    Kann ich das schon ganz am Anfang abfangen.
    Also von allen fortlaufenden Roll, Pitch und Yaw Werten immer den ersten Roll, Pitch und Yaw Wert abziehe.
    Ich hoffe das ist verständlich ausgedrückt.

    Oder muss ich das wieder mit einer Rotationsmatrix machen?
    Also das sich zuerst den Würfel mit den negativen Roll, Pitch und Yaw Werten mit der Rotationsmatrix verdrehe.
    Und mit die neu errechneten Koordinaten dann als neue Grundposition für alle folgenden Rotationen berechen.

    Oder muss ich das auf einen ganz andren Weg lösen?
    Wie nennt sich das? Koordinaten Transformation?


    LG Sara
    Die Antwort verstehe ich nicht.
    Ich hoffe ich habe mein Problem verständlich beschrieben.
    Ich möchte das mein Würfel die Rotationen aus einer Datei in der RPY Werte stehen übernimmt.
    Aber, der Würfel soll die Rotationen mit seiner Ausgangsposition machen.
    Ich muss den Würfel in diesem Fall immer um den negativen ersten Wert verdrehen. Oder sehe ich das falsch?

    LG Sara
    Hi
    könntest du nicht einfach die Rohwerte des Würfels behalten und vor jeder Darstellung mit der Matrix multiplizieren?
    Mit was stellst du das ganze dar? GPU-beschleunigt oder auf CPU? (könnte man ggf. nämlich auf die GPU auslagern, falls die CPU es nicht mehr packt)
    Ggf. ist es auch sinnvoll, pro RPY-Werte einen eigenen Würfel zu verwenden, das wäre speicherbelastender, aber dafür von der Berechnung her weniger intensiv. Man sollte anmerken, dass Sinus, Cosinus (und auch Wurzeln, sonst könnte man hin-und-her-Rechnen) rechenintensiv sind, auch wenn sie durch Spline-Interpolation angenähert werden können. Daher wäre es sinnvoll, nicht die RPY-Werte, sondern die Matrizen zu halten (eine Matrix hat 4*4 Werte, ein Würfel 3*8, liegt also bei dir, was für dich praktischer ist).
    War das ungefähr das, was du machen willst?

    Gruß
    ~blaze~
    Hallo blaze,
    ich nutze VB Media 3D.
    Außerdem behalte ich immer die die Ausgangsposition des Würfels.
    Für jedes Frame lösche ich die ganze 3D Ansicht und zeichne alles neu.

    @könntest du nicht einfach die Rohwerte des Würfels behalten und vor jeder Darstellung mit der Matrix multiplizieren?
    Ich denke das ich das so mache. Aber Wie schon erwähnt möchte ich AUF KEINEN FALL das der Würfel die Position genau übernimmt.
    Er soll die Rotation in Relation zur seiner Ausgangsposition übernehmen. Also ein Rotations offSet.

    Hier ist ein Auszug aus meinem Code.
    Zur Zeit ist extra etwas ausführlicher aber deshalb besser zu verstehen.

    LG Sara

    VB.NET-Quellcode

    1. 'MATRIX ROTATION Z Achse
    2. 'Cos(roll) * x - Sin(roll) * y
    3. 'Sin(roll) * x + Cos(roll) * y
    4. MR_Z11 = Cos(roll)
    5. MR_Z12 = (-1) * Sin(roll)
    6. MR_Z13 = 0
    7. MR_Z21 = Sin(roll)
    8. MR_Z22 = Cos(roll)
    9. MR_Z23 = 0
    10. MR_Z31 = 0
    11. MR_Z32 = 0
    12. MR_Z33 = 1
    13. 'MATRIX ROTATION X Achse
    14. 'Cos(pitch) * y - Sin(pitch) * z
    15. 'Sin(pitch) * y + Cos(pitch) * z
    16. MR_X11 = 1
    17. MR_X12 = 0
    18. MR_X13 = 0
    19. MR_X21 = 0
    20. MR_X22 = Cos(pitch)
    21. MR_X23 = (-1) * Sin(pitch)
    22. MR_X31 = 0
    23. MR_X32 = Sin(pitch)
    24. MR_X33 = Cos(pitch)
    25. 'MATRIX ROTATION Y Achse
    26. 'Cos(yaw) * x - Sin(yaw) * z
    27. 'Sin(yaw) * x + Cos(yaw) * z
    28. MR_Y11 = Cos(yaw)
    29. MR_Y12 = 0
    30. MR_Y13 = (-1) * Sin(yaw)
    31. MR_Y21 = 0
    32. MR_Y22 = 1
    33. MR_Y23 = 0
    34. MR_Y31 = Sin(yaw)
    35. MR_Y32 = 0
    36. MR_Y33 = Cos(yaw)
    37. 'MATRIX ROTATION Z * Y
    38. MR_ZY11 = MR_Z11 * MR_Y11 + MR_Z12 * MR_Y21 + MR_Z13 * MR_Y31
    39. MR_ZY12 = MR_Z11 * MR_Y12 + MR_Z12 * MR_Y22 + MR_Z13 * MR_Y32
    40. MR_ZY13 = MR_Z11 * MR_Y13 + MR_Z12 * MR_Y23 + MR_Z13 * MR_Y33
    41. MR_ZY21 = MR_Z21 * MR_Y11 + MR_Z22 * MR_Y21 + MR_Z23 * MR_Y31
    42. MR_ZY22 = MR_Z21 * MR_Y12 + MR_Z22 * MR_Y22 + MR_Z23 * MR_Y32
    43. MR_ZY23 = MR_Z21 * MR_Y13 + MR_Z22 * MR_Y23 + MR_Z23 * MR_Y33
    44. MR_ZY31 = MR_Z31 * MR_Y11 + MR_Z32 * MR_Y21 + MR_Z33 * MR_Y31
    45. MR_ZY32 = MR_Z31 * MR_Y12 + MR_Z32 * MR_Y22 + MR_Z33 * MR_Y32
    46. MR_ZY33 = MR_Z31 * MR_Y13 + MR_Z32 * MR_Y23 + MR_Z33 * MR_Y33
    47. 'MATRIX ROTATION ZY * X
    48. MR_ZYX11 = MR_ZY11 * MR_X11 + MR_ZY12 * MR_X21 + MR_ZY13 * MR_X31
    49. MR_ZYX12 = MR_ZY11 * MR_X12 + MR_ZY12 * MR_X22 + MR_ZY13 * MR_X32
    50. MR_ZYX13 = MR_ZY11 * MR_X13 + MR_ZY12 * MR_X23 + MR_ZY13 * MR_X33
    51. MR_ZYX21 = MR_ZY21 * MR_X11 + MR_ZY22 * MR_X21 + MR_ZY23 * MR_X31
    52. MR_ZYX22 = MR_ZY21 * MR_X12 + MR_ZY22 * MR_X22 + MR_ZY23 * MR_X32
    53. MR_ZYX23 = MR_ZY21 * MR_X13 + MR_ZY22 * MR_X23 + MR_ZY23 * MR_X33
    54. MR_ZYX31 = MR_ZY31 * MR_X11 + MR_ZY32 * MR_X21 + MR_ZY33 * MR_X31
    55. MR_ZYX32 = MR_ZY31 * MR_X12 + MR_ZY32 * MR_X22 + MR_ZY33 * MR_X32
    56. MR_ZYX33 = MR_ZY31 * MR_X13 + MR_ZY32 * MR_X23 + MR_ZY33 * MR_X33
    57. 'Punkt Koordinaten neu berechnen mesh_points(ID_Punkt, Xwert) mesh_points(ID_Punkt, Ywert), mesh_points(ID_Punkt, Zwert)
    58. tmpX = MR_ZYX11 * mesh_points(0, 0) + MR_ZYX12 * mesh_points(0, 1) + MR_ZYX13 * mesh_points(0, 2)
    59. tmpY = MR_ZYX21 * mesh_points(0, 0) + MR_ZYX22 * mesh_points(0, 1) + MR_ZYX23 * mesh_points(0, 2)
    60. tmpZ = MR_ZYX31 * mesh_points(0, 0) + MR_ZYX32 * mesh_points(0, 1) + MR_ZYX33 * mesh_points(0, 2)
    Ich hab's denk ich noch nicht ganz begriffen. Wenn die Ausgangsposition mit eingerechnet werden soll, ist das doch eigentlich einfach eine Matrix-Multiplikation mit dieser. Der resultierende Wert wäre dann eben der neue Vektor, oder? Woher ergibt sich der Ausgangswert bzw. warum ist es nicht so?

    Du kannst übrigens die Sin(winkel) und Cos(winkel) in eine Variable zwischenspeichern und Matrix direkt in eine Structure auslagern.

    Gruß
    ~blaze~
    Hallo blaze
    ich bin mir bewusst das man den Code noch optimieren kann.
    Mir ging es aber es erst mal um eine gute Lesbarkeit.
    Frame Roll Pitch Yaw
    1 30 40 10
    2 32 41 12
    u.s.w.

    Was ich probiert habe ist, ich habe den die ersten RPY Werte von allen folgenden abgezogen.
    Also immer 30 , 40 und 10 von allen folgenden Werten subtrahieren.
    Das hat aber nicht funktioniert.

    Dann habe ich den Code oben 2 mal hintereinander laufen lassen. (Nur zum testen)
    Das erste mal mit den negativen Werten aus Frame 1 also -30 -40 -10
    Die daraus neu entstandenen Koordinaten habe ich dann erneut gedreht.
    Also mit 32, 41,12

    Aber es hat nicht funktioniert.


    Was mir am liebste wäre sind transformierte RPY Werte.
    So kann ich die neu in eine Dateispeicher und spare mir das umrechnen.
    Das spart ja auch schon mal viel Rechenleistung ein.

    Macht man das mit einem Einheitsvektor?
    Ich glaub ich verfüge gerade über das gefährlich Halbwissen.
    Ich befasse mich mit dem Thema erst seit ein paar Wochen und bin noch Anfänger.


    LG Sara
    Einheitsvektoren sind einfach Vektoren mit der Länge 1. Für mich sieht's so aus, als wäre das einfach eine zeitliche Abfolge von Darstellungen des Würfels. Könntest du nicht einfach die RPY-Matrix für den i-ten Frame aufstellen und einen Würfel mit den Eckpunkten (0, 0, 0), (0, 0, l), (0, l, l), (0, l, 0), (l, 0, 0), (l, l, 0), (l, l, l), (l, 0, l) damit transformieren (l ist die Seitenlänge)? Die Eckpunkte des Würfels würde man dann einzeln transformieren und das Resultat würde dargestellt. Jede Transformation ist dann unabhängig von der vorhergehenden, wenn du den Würfel nicht überschreibst, da die Werte fortlaufend sind.

    Gruß
    ~blaze~
    Hallo blaze, ich glaube wie reden aneinander vorbei.
    Das was Du beschreibst mache ich doch derzeit. Ich habe einen Würfel mit 8 Eckpunkten.
    Für alle 8 Werte berechnen ich mit dem Code oben die neuen temporären Eckwerte.
    Der Code oben ist doch eine RPY-Matrix.

    Ich will aber nicht das der Würfel genau die Rotation eins zu ein übernimmt.
    Die Werte der Datei stimmen nicht mit meinen Koordinatensystem genau überein.
    Sie müssen korrigiert werden.
    Was mir am liebsten ist, ich möchte die RPY Werte korrigieren.
    Genau so das die RPY Datei mit 0,0,0 beginnt.
    Also neue RPY Werte erzeugen.

    Also wenn man das auf eine Achse bezieht.
    Frame 1: Winkel 10 Grad => 0 Grad
    Frame 2: Winkel 12 Grad => 2 Grad
    Frame 3: Winkel 8 Grad => -2 Grad
    Frame 4: Winkel 6 Grad =>-4 Grad

    LG Sara
    Das beschrieben wäre ja eigentlich wirklich, den ersten Winkel von den nachfolgenden Winkeln abzuziehen, sodass RPY_i = RPY_i - RPY_0. Pro generiertem RPY_i erzeugst du dann eine neue Transformationsmatrix, die den Würfel neu transformiert.
    Ist das die einzige Korrektur, die du durchführen möchtest? *hofft, dass er es jetzt geschnallt hat* ;)

    Gruß
    ~blaze~

    Sara schrieb:

    immer den ersten Roll, Pitch und Yaw Wert abziehe.
    Diese Herangehensweise ist absolut falsch, Du solltest erst mal ein Gefühl für 3D-Rotation entwickeln.
    Das Problem ist, dass Rotationen nicht vertauschbar sind.
    Beispiel:
    Nimm einen Spielwürfel, drehe ihn nach vorn und dann nach rechts.
    Nimm einen 2. Würfel, drehe ihn nach rechts und dann nach vorn.

    Solange Du solch nicht verinnerlicht hast, solltest Du nicht weiter proggen, denn Du kannst nicht überprüfen, ob das, was Du da ausrechnest, auch richtig ist!
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!