Saltar al contenido

¿Cómo rotas un vector por un cuaternión unitario?

Si encuentras alguna parte que te causa duda nos puedes dejar un comentario y te ayudaremos rápidamente.

Solución:

Para responder a la pregunta simplemente, dado:

 P  = [0, p1, p2, p3]  <-- point vector
 R  = [w,  x,  y,  z]  <-- rotation
 R' = [w, -x, -y, -z]

Para el ejemplo en la pregunta, estos son:

 P  = [0, 1, 0, 0]
 R  = [0.707, 0.0,  0.707, 0.0]
 R' = [0.707, 0.0, -0.707, 0.0]

Puedes calcular el vector resultante usando el producto de Hamilton H(a, b) por:

 P' = RPR'
 P' = H(H(R, P), R')

Realización de los cálculos:

        H(R, P)      = [0.0, 0.707, 0.0, -0.707]
 P' = H(H(R, P), R') = [0.0, 0.0,   0.0, -1.0  ]

Por lo tanto, el ejemplo anterior ilustra una rotación de 90 grados sobre el eje y para el punto (1, 0, 0). El resultado es (0, 0, -1). (Tenga en cuenta que el primer elemento de P' siempre será 0 y por lo tanto puede ser descartado.)

Para aquellos que no están familiarizados con los cuaterniones, vale la pena señalar que el cuaternión R puede determinarse mediante la fórmula:

a = angle to rotate
[x, y, z] = axis to rotate around (unit vector)

R = [cos(a/2), sin(a/2)*x, sin(a/2)*y, sin(a/2)*z]

Vea aquí para más referencias.

Parece que tienes muchos problemas con esto, debido a varias preguntas. Al mismo tiempo, confío en que no obtendrá respuestas satisfactorias mientras se ciña a la terminología que está utilizando. Tal vez en el sitio de desbordamiento de pila original, dirigido a programadores.

Lea esto: http://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation

y esto: http://en.wikipedia.org/wiki/Quaternions

Para responder no mucho más a tu pregunta, cualquier cuaternión es una expresión $$ q = w + x ; mathbfi + y ; mathbfj + z ; mathbfk.$$ donde las reglas de multiplicación usan $$ mathbfi^2 = mathbfj^2 = mathbfk^2 = mathbfi mathbfj mathbfk = -1, $$ y las consecuencias de eso, vea wikipedia como dije. Cualquier cuaternión $ q = w + x ; mathbfi + y ; mathbfj + z ; mathbfk$ tiene un conjugado, que en wikipedia se escribe $q^ast,$ dado por $$ q^ast = w - x ; mathbfi - y ; mathbfj - z ; mathbfk.$$

La "norma" del cuaternión $q$ es exactamente $$ parallel q parallel^2 = w^2 + x^2 + y^2 + z^2 = qq^ast = q^ast q$$

Un cuaternión $q$ se llama cuaternión de "unidad" cuando $$ w^2 + x^2 + y^2 + z^2 = 1. $$

Un cuaternión se llama "puro" o un vector en 3 espacios cuando $ w = 0,$ por lo que un vector en 3 espacios es $$ v = v_1 ; mathbfi + v_2 ; mathbfj + v_3 ; mathbfk $$ No tengo idea de cómo los ingenieros y programadores llaman a estos conceptos. Estás preguntando a los matemáticos.

Dados dos cuaterniones, la norma del producto es el producto de las normas.

La "parte real" (la $w$) del producto de dos cuaterniones $pq$ es la misma que la "parte real de $qp.$

Entonces, ¿qué sucede cuando tomo un cuaternión unidad $q$ y un cuaternión "puro" $v,$ y calculo $$ p = q^ast v q.$$

Bueno, tenemos $$parallel p parallel = 1 cdot parallel v parallel cdot 1 = parallel v parallel $$

Pero en cuanto a la "parte real", comenzamos con $$ Re v = 0,$$

entonces $$ Re q^ast (vq) = Re (vq) q^ast = Re v (qq^ast) = Re v = 0. $$

Así que $ p = q^ast vq$ es otro cuaternión puro, otro "vector", de la misma longitud que $v,$ pero girado desde donde estaba.

Eso es suficiente para empezar.

La respuesta anterior de Doug ha sido extraordinariamente útil para mí. Lo que es difícil con muchas explicaciones de los cuaterniones y sus aplicaciones es que la notación es difícil de leer y comprender para los alumnos.

Este sitio de Mathworks explica con más detalle cómo multiplicar cuaterniones: http://www.mathworks.com/help/aerotbx/ug/quatmultiply.html?requestedDomain=www.mathworks.com

También tiendo a pensar y aprender en términos de código. Esto es lo que finalmente pude reconstruir en python:

def quaternion_mult(q,r):
    return [r[0]*q[0]-r[1]*q[1]-r[2]*q[2]-r[3]*q[3],
            r[0]*q[1]+r[1]*q[0]-r[2]*q[3]+r[3]*q[2],
            r[0]*q[2]+r[1]*q[3]+r[2]*q[0]-r[3]*q[1],
            r[0]*q[3]-r[1]*q[2]+r[2]*q[1]+r[3]*q[0]]

def point_rotation_by_quaternion(point,q):
    r = [0]+point
    q_conj = [q[0],-1*q[1],-1*q[2],-1*q[3]]
    return quaternion_mult(quaternion_mult(q,r),q_conj)[1:]

print(point_rotation_by_quaternion([1, 0, 0],[0.7071203316249954, 0.0, 0.7071203316249954, 0.0])

Reseñas y valoraciones del tutorial

Agradecemos que quieras añadir valor a nuestra información añadiendo tu veteranía en las interpretaciones.

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *