Quaternion d'angles d'Euler algorithme - Comment convertir à "Y =" et entre le despotisme?

J'ai un algorithme de conversion entre un Quaternion et les angles d'Euler.

    public static Vector3 ToEulerAngles(this Quaternion q)
{
//Store the Euler angles in radians
Vector3 pitchYawRoll = new Vector3();
double sqw = q.W * q.W;
double sqx = q.X * q.X;
double sqy = q.Y * q.Y;
double sqz = q.Z * q.Z;
//If quaternion is normalised the unit is one, otherwise it is the correction factor
double unit = sqx + sqy + sqz + sqw;
double test = q.X * q.Y + q.Z * q.W;
if (test > 0.4999f * unit)                              //0.4999f OR 0.5f - EPSILON
{
//Singularity at north pole
pitchYawRoll.Y = 2f * (float)Math.Atan2(q.X, q.W);  //Yaw
pitchYawRoll.X = PI * 0.5f;                         //Pitch
pitchYawRoll.Z = 0f;                                //Roll
return pitchYawRoll;
}
else if (test < -0.4999f * unit)                        //-0.4999f OR -0.5f + EPSILON
{
//Singularity at south pole
pitchYawRoll.Y = -2f * (float)Math.Atan2(q.X, q.W); //Yaw
pitchYawRoll.X = -PI * 0.5f;                        //Pitch
pitchYawRoll.Z = 0f;                                //Roll
return pitchYawRoll;
}
else
{
pitchYawRoll.Y = (float)Math.Atan2(2f * q.Y * q.W - 2f * q.X * q.Z, sqx - sqy - sqz + sqw);       //Yaw
pitchYawRoll.X = (float)Math.Asin(2f * test / unit);                                             //Pitch
pitchYawRoll.Z = (float)Math.Atan2(2f * q.X * q.W - 2f * q.Y * q.Z, -sqx + sqy - sqz + sqw);      //Roll
}
return pitchYawRoll;
}

Cette méthode ne fonctionne que pour un droitier système de coordonnées Cartésiennes avec l'axe des Z vers le haut.

Que serais-je changer dans l'ordre à faire l'axe Y d'un point, jusqu'à la place de Z? (Serait-permutation de X et Z de travail?)

Comment puis-je accueillir gaucher systèmes de coordonnées?

EDIT:

public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
{
float num = roll * 0.5f;
float num2 = (float)Math.Sin((double)num);
float num3 = (float)Math.Cos((double)num);
float num4 = pitch * 0.5f;
float num5 = (float)Math.Sin((double)num4);
float num6 = (float)Math.Cos((double)num4);
float num7 = yaw * 0.5f;
float num8 = (float)Math.Sin((double)num7);
float num9 = (float)Math.Cos((double)num7);
Quaternion result;
result.X = num9 * num5 * num3 + num8 * num6 * num2;
result.Y = num8 * num6 * num3 - num9 * num5 * num2;
result.Z = num9 * num6 * num2 - num8 * num5 * num3;
result.W = num9 * num6 * num3 + num8 * num5 * num2;
return result;
}
Les Quaternions et les angles d'euler sont indépendantes l'une de l'alignement du système de coordonnées et de la tête. Lacet, tangage et roulis définir les rotations sur le z, y et x de l'axe respecitvely. Il n'a pas d'importance, la façon dont les axes sont orientés.
Si je l'utiliser en combinaison avec le XNA du Quaternion.CreateFromYawPitchRoll alors je n'ai pas l'original de Quaternions. msdn.microsoft.com/en-us/library/...
Ensuite, les fonctions probablement utiliser différentes associations de lacet/pitch/roll pour les axes. Swap les angles d'euler, de sorte que les définitions de match .
Pourriez-vous s'il vous plaît poster un exemple basé sur l'ÉDITION que j'ai faites, qui comprend désormais le Quaternion.CreateFromYawPitchRoll?

OriginalL'auteur user1423893 | 2012-07-15

  1. 11

    Voici changé les méthodes qui utilisent la même définition de lacet, tangage, roulis:

    public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
{
float rollOver2 = roll * 0.5f;
float sinRollOver2 = (float)Math.Sin((double)rollOver2);
float cosRollOver2 = (float)Math.Cos((double)rollOver2);
float pitchOver2 = pitch * 0.5f;
float sinPitchOver2 = (float)Math.Sin((double)pitchOver2);
float cosPitchOver2 = (float)Math.Cos((double)pitchOver2);
float yawOver2 = yaw * 0.5f;
float sinYawOver2 = (float)Math.Sin((double)yawOver2);
float cosYawOver2 = (float)Math.Cos((double)yawOver2);
Quaternion result;
result.X = cosYawOver2 * cosPitchOver2 * cosRollOver2 + sinYawOver2 * sinPitchOver2 * sinRollOver2;
result.Y = cosYawOver2 * cosPitchOver2 * sinRollOver2 - sinYawOver2 * sinPitchOver2 * cosRollOver2;
result.Z = cosYawOver2 * sinPitchOver2 * cosRollOver2 + sinYawOver2 * cosPitchOver2 * sinRollOver2;
result.W = sinYawOver2 * cosPitchOver2 * cosRollOver2 - cosYawOver2 * sinPitchOver2 * sinRollOver2;
return result;
}

    Pour ToEulerAngles (singularités omises):

    pitchYawRoll.Y = (float)Math.Atan2(2f * q.X * q.W + 2f * q.Y * q.Z, 1 - 2f * (sqz  + sqw));     //Yaw 
pitchYawRoll.X = (float)Math.Asin(2f * ( q.X * q.Z - q.W * q.Y ) );                             //Pitch 
pitchYawRoll.Z = (float)Math.Atan2(2f * q.X * q.Y + 2f * q.Z * q.W, 1 - 2f * (sqy + sqz));      //Roll

    J'ai effectué le test suivant:

    var q = CreateFromYawPitchRoll(0.2f, 0.3f, 0.7f);
var e = ToEulerAngles(q);
var q2 = CreateFromYawPitchRoll(e.Y, e.X, e.Z);

    avec les résultats suivants;

    e = (0.3, 0.2, 0.7) //pitch, yaw, roll
q2 = q

    Source: Wikipédia

    Excellente réponse, merci. Sont les singularités de corriger comme écrit à l'origine?
    if (test > 0.4999f * unit) // 0.4999f OR 0.5f - EPSILON { // Singularity at north pole pitchYawRoll.Y = 2f * (float)Math.Atan2(q.Y, q.W); // Yaw pitchYawRoll.X = PI * 0.5f; // Pitch pitchYawRoll.Z = 0f; // Roll return pitchYawRoll; }
    Viens de vérifier, PI ne produit pas les résultats corrects. Par exemple FromYawPitchRoll((float)Math.PI, 0f, 0f)
    test doit être = q.X * q.Z - q.W * q.Y. Cependant, je ne suis pas absolument sûr, à propos de la singularité des valeurs. Vous êtes mieux de l'essayer.
    L'équation "test" ne peut pas être correcte. Il produit une valeur de 0 pour les deux (0, 0, 0) et (PI, 0, 0).

    OriginalL'auteur Nico Schertler