girando un cuaternión en 1 eje?

Question

Tengo un modelo girado por un cuaternión. Solo puedo configurar la rotación, no puedo sumar ni restar de nada. Necesito obtener el valor de un eje, y luego agregarle un ángulo (¿tal vez un grado o radianes?) Y luego volver a agregar el cuaternión modificado.

¿Cómo puedo hacer esto? (respuesta en cada eje).

Answer 1

Puede multiplicar dos cuaterniones para producir un tercer cuaternión que es el resultado de las dos rotaciones. Tenga en cuenta que la multiplicación del cuaternión no es conmutativa, lo que significa que el orden importa (si hace esto en su cabeza varias veces, puede ver por qué).

Puede producir un cuaternión que representa una rotación en un ángulo dado en torno a un eje determinado con algo como esto (excusa el hecho de que es C++, no java):

Quaternion Quaternion::create_from_axis_angle(const double &xx, const double &yy, const double &zz, const double &a) 
{ 
    // Here we calculate the sin(theta/2) once for optimization 
    double factor = sin(a/2.0); 

    // Calculate the x, y and z of the quaternion 
    double x = xx * factor; 
    double y = yy * factor; 
    double z = zz * factor; 

    // Calcualte the w value by cos(theta/2) 
    double w = cos(a/2.0); 

    return Quaternion(x, y, z, w).normalize(); 
} 

Así que para girar alrededor del eje x, por ejemplo, puede crear un cuaternión con createFromAxisAngle(1, 0, 0, M_PI/2) y multiplicarlo por el cuaternión de rotación actual de su modelo.

Answer 2

Hice un código de la publicación de sje397 para probar otros detalles más tarde, pensé que compartiría. Eventualmente usando C el motivo de ninguna clase de Quaternion.

#include <iostream> 
#include <math.h> 
using namespace std; 

struct float4{ 
    float x; 
    float y; 
    float z; 
    float w; 
}; 
float4 make_float4(float x, float y, float z, float w){ 
    float4 quat = {x,y,z,w}; 
    return quat; 
} 
float dot(float4 a) 
{ 
    return (((a.x * a.x) + (a.y * a.y)) + (a.z * a.z)) + (a.w * a.w); 
} 
float4 normalize(float4 q) 
{ 
    float num = dot(q); 
    float inv = 1.0f/(sqrtf(num)); 
    return make_float4(q.x * inv, q.y * inv, q.z * inv, q.w * inv); 
} 
float4 create_from_axis_angle(const float &xx, const float &yy, const float &zz, const float &a) 
{ 
    // Here we calculate the sin(theta/2) once for optimization 
    float factor = sinf(a/2.0f); 

    float4 quat; 
    // Calculate the x, y and z of the quaternion 
    quat.x = xx * factor; 
    quat.y = yy * factor; 
    quat.z = zz * factor; 

    // Calcualte the w value by cos(theta/2) 
    quat.w = cosf(a/2.0f); 
    return normalize(quat); 
} 
int main() 
{ 
    float degrees = 10.0f; 
    float4 quat = create_from_axis_angle(1, 0, 0, degrees*(3.14159f/180.0f)); 
    cout << "> (" << quat.x << ", " <<quat.y << ", " <<quat.z << ", " <<quat.w << ")" << endl; 
    return 0; 
} 

salida

(0,0871557, 0, 0, 0,996195)