Componente di una rotazione quaternion attorno ad un asse

Question

Non riesco a trovare alcuna informazione valida su questo argomento. Fondamentalmente voglio trovare il componente di una rotazione quaternion, cioè attorno ad un dato asse (non necessariamente X, Y o Z - qualsiasi vettore di unità arbitrarie). Un po 'come proiettare un quaternione su un vettore. Quindi, se dovessi chiedere la rotazione attorno ad un asse parallelo all'asse del quaternario, avrei recuperato lo stesso quaterno. Se dovessi chiedere la rotazione attorno a un asse ortogonale all'asse del quaternario, uscirò da un quaternario di identità. E tra ... beh, questo è quello che mi piacerebbe sapere come risolvere :)

Answer 1

Ho trascorso l'altro giorno cercando di trovare la stessa identica cosa per un editor di animazione; ecco come l'ho fatto:

1. Prendi l'asse in cui vuoi trovare la rotazione e trova un vettore ortogonale.
2. Ruota questo nuovo vettore utilizzando il quaternione.
3. progetto questo ruotato vettore sul piano la cui normale è dell'asse

4. l'Acos del prodotto scalare di questo vettore e proiettate ortogonale originale è l'angolo.

   public static float FindQuaternionTwist(Quaternion q, Vector3 axis) 
   { 
       axis.Normalize(); 
   
       // Get the plane the axis is a normal of 
       Vector3 orthonormal1, orthonormal2; 
       ExMath.FindOrthonormals(axis, out orthonormal1, out orthonormal2); 
   
       Vector3 transformed = Vector3.Transform(orthonormal1, q); 
   
       // Project transformed vector onto plane 
       Vector3 flattened = transformed - (Vector3.Dot(transformed, axis) * axis); 
       flattened.Normalize(); 
   
       // Get angle between original vector and projected transform to get angle around normal 
       float a = (float)Math.Acos((double)Vector3.Dot(orthonormal1, flattened)); 
   
       return a; 
   } 
   

Ecco il codice per trovare le orthonormals però probabilmente si può fare molto meglio se desideri solo quello per il metodo di cui sopra:

private static Matrix OrthoX = Matrix.CreateRotationX(MathHelper.ToRadians(90)); 
private static Matrix OrthoY = Matrix.CreateRotationY(MathHelper.ToRadians(90)); 

public static void FindOrthonormals(Vector3 normal, out Vector3 orthonormal1, out Vector3 orthonormal2) 
{ 
    Vector3 w = Vector3.Transform(normal, OrthoX); 
    float dot = Vector3.Dot(normal, w); 
    if (Math.Abs(dot) > 0.6) 
    { 
     w = Vector3.Transform(normal, OrthoY); 
    } 
    w.Normalize(); 

    orthonormal1 = Vector3.Cross(normal, w); 
    orthonormal1.Normalize(); 
    orthonormal2 = Vector3.Cross(normal, orthonormal1); 
    orthonormal2.Normalize(); 
} 

Anche se quanto sopra esposto opere si possono trovare non si comporta come ci si aspetterebbe. Ad esempio, se il quaternione ruota un vettore di 90 gradi. intorno a X e 90 gradi. intorno a Y troverai se decomponi la rotazione attorno a Z sarà 90 gradi. anche. Se si immagina un vettore che esegue queste rotazioni, ciò ha perfettamente senso, ma a seconda dell'applicazione potrebbe non essere il comportamento desiderato. Per la mia applicazione - vincolare i giunti di scheletro - ho finito con un sistema ibrido. Matrici/Quat usati ovunque, ma quando si trattava del metodo per vincolare le giunzioni, ho usato angoli euler internamente, scomponendo il quat di rotazione a rotazioni attorno a X, Y, Z ogni volta.

Buona fortuna, spero che abbia aiutato.

Answer 2

ho cercato di implementare la risposta di sebf, sembra buono, tranne che la scelta della scelta del vettore al punto 1:

1. Prendere l'asse che si desidera trovare la rotazione intorno, e trovare un vettore ortogonale ad esso.

non è sufficiente per risultati ripetibili. L'ho sviluppato su carta e suggerisco la seguente linea di condotta per la scelta del vettore ortogonale all '"asse in cui si desidera trovare la rotazione attorno", cioè l'asse di osservazione. Esiste un piano ortogonale all'asse di osservazione. Devi proiettare l'asse di rotazione del tuo quaternione su questo piano. L'uso di questo vettore risultante come il vettore ortogonale all'asse di osservazione darà buoni risultati.

Grazie a sebf per avermi impostato sulla giusta rotta.

Answer 3

C'è una soluzione elegante per questo problema, particolarmente adatto per quaternioni.E 'noto come il "swing torsione di decomposizione":

in pseudocodice

/** 
    Decompose the rotation on to 2 parts. 
    1. Twist - rotation around the "direction" vector 
    2. Swing - rotation around axis that is perpendicular to "direction" vector 
    The rotation can be composed back by 
    rotation = swing * twist 

    has singularity in case of swing_rotation close to 180 degrees rotation. 
    if the input quaternion is of non-unit length, the outputs are non-unit as well 
    otherwise, outputs are both unit 
*/ 
inline void swing_twist_decomposition(const xxquaternion& rotation, 
             const vector3&  direction, 
             xxquaternion&  swing, 
             xxquaternion&  twist) 
{ 
    vector3 ra(rotation.x, rotation.y, rotation.z); // rotation axis 
    vector3 p = projection(ra, direction); // return projection v1 on to v2 (parallel component) 
    twist.set(p.x, p.y, p.z, rotation.w); 
    twist.normalize(); 
    swing = rotation * twist.conjugated(); 
} 

E la risposta lunga e derivazione di questo codice può essere trovato qui http://www.euclideanspace.com/maths/geometry/rotations/for/decomposition/