Obracanie wektora3 o ćwiartkę

Próbuję obrócić wektor3 o dany czwartorzęd.

Wiem, że to prawda

$$v' = q \cdot v \cdot q^{-1}$$

Wiem, że jest odwrotnością, która po prostu , ale jak mam odwzorować mnożenie wektora na czwartorzęd, aby odzyskać wektor?$q^{-1}$$\frac {-q} {magnitude(q)}$

Odkryłem, że można traktować jak macierz i konwertować i na macierze, a następnie konwertować z macierzy na wektor, ale wydaje się to nieco przesadne, aby uzyskać wektor. Czy istnieje czystsza implementacja, której mógłbym użyć?$v$$q$$q'$$v'$

Jak ujawnili Nathan Reed i teodron, receptą na obrót wektora v o czwartorzędową jednostkę długości q jest:

1) Utwórz czysty czwartorzęd p z v . Oznacza to po prostu dodanie czwartej współrzędnej 0:

$$p = (v_x, v_y, v_z, 0) \Leftrightarrow p = (v, 0)$$

2) Pomnóż go wstępnie przez q, a następnie pomnóż go przez koniugat q * :

$$p' = q \times p \times q*$$

3) Spowoduje to powstanie kolejnego czystego czwartorzędu, który można odwrócić do wektora:

$$v' = (p'_x, p'_y, p'_z)$$

Ten wektor jest obrócony o .$v'$$v$$q$

---

To działa, ale dalekie od optymalnego . Mnożenia czwartorzędu oznaczają tony operacji. Byłem ciekawy różnych wdrożeń, takich jak ten , i postanowiłem dowiedzieć się, skąd one pochodzą. Oto moje ustalenia.

Możemy również opisać q jako połączenie trójwymiarowego wektora u i skalara s :

$$q = (u_x, u_y, u_z, s) \Leftrightarrow q = (u, s)$$

Zgodnie z regułami mnożenia czwartorzędu i ponieważ koniugat czwartorzędu o długości jednostki jest po prostu odwrotny, otrzymujemy:

$$\begin{align} p' &= qpq* \\ &= (u, s)(v,0)(-u, s) \\ &= (sv + u \times v, -u \cdot v)(-u, s) \\ &= ((-u \cdot v)(-u) + s(sv + u \times\ v) + (sv + u \times v) \times (-u), \dots) \\ &= ((u \cdot v) u + s^2v + s(u \times v) + sv \times (-u) + (u \times v) \times (-u), \dots) \end{align}$$

Część skalarna (elipsy) daje zero, jak wyszczególniono tutaj . Interesująca jest część wektorowa, AKA nasz obrócony wektor v ' . Można to uprościć za pomocą podstawowych tożsamości wektorowych :

$$\begin{align} v' &= (u \cdot v)u + s^2v + s(u \times v) + s(u \times v) + u \times (u \times v) \\ &= (u \cdot v)u + s^2v + 2s(u \times v) + (u \cdot v)u - (u \cdot u)v \\ &= 2(u \cdot v)u + (s^2 - u \cdot u)v + 2s(u \times v) \end{align}$$

Jest to teraz o wiele bardziej optymalne ; dwa produkty kropkowe, produkt krzyżowy i kilka dodatków: około połowa operacji. Co dałoby coś takiego w kodzie źródłowym (przy założeniu jakiejś ogólnej biblioteki matematycznej wektorowej):

void rotate_vector_by_quaternion(const Vector3& v, const Quaternion& q, Vector3& vprime)
{
    // Extract the vector part of the quaternion
    Vector3 u(q.x, q.y, q.z);

    // Extract the scalar part of the quaternion
    float s = q.w;

    // Do the math
    vprime = 2.0f * dot(u, v) * u
          + (s*s - dot(u, u)) * v
          + 2.0f * s * cross(u, v);
}

Przede wszystkim q ^ (-1) nie jest -q / magnituda (q); to q * / (magnituda (q)) ^ 2 (q * to koniugat; który neguje wszystkie składniki oprócz rzeczywistego). Oczywiście możesz pominąć podział według wielkości, jeśli wszystkie twoje czwartorzędy są już znormalizowane, co zwykle byłoby w systemie rotacji.

Jeśli chodzi o mnożenie przez wektor, wystarczy rozszerzyć wektor do czwartorzędu, ustawiając rzeczywisty komponent quatu na zero, a jego komponenty ijk na xyz wektora. Następnie wykonujesz mnożenie czwartorzędu, aby uzyskać v ', a następnie ponownie rozpakuj komponenty ijk. (Rzeczywista część v 'powinna zawsze wychodzić na zero, plus lub minus jakiś błąd zmiennoprzecinkowy.)

Pierwsza obserwacja: Odwrotność qnie jest -q/magnitude(q), to jest całkowicie błędne. Obroty z czwartorzędami sugerują, że te ekwiwalenty liczby zespolonej 4D mają normę jednostkową, a zatem leżą na sferze jednostki S3 w tej przestrzeni 4D. Fakt, że quat jest jednolity, oznacza, że ​​jego normą jest, norm(q)^2=q*conjugate(q)=1a to oznacza, że ​​odwrotność quatu jest jego koniugatem.

Jeśli czwartorzędowa jednostka jest zapisana jako q=(w,x,y,z)= (cos (t), sin (t) v ), to jej sprzężeniem jest conjugate(q)=(w,-x,-y,-z)= (cos (t), - sin (t) v ), gdzie t jest połową kąta obrotu v jest osią obrotu (oczywiście jako wektor jednostkowy).

Kiedy ten koleś z Hamilton zdecydował się bawić z ekwiwalentami liczb zespolonych w wyższych wymiarach, natknął się również na kilka dobrych właściwości. Na przykład, jeśli zastosujesz całkowicie czysty czwartorzęd q=(0,x,y,z)(bez części skalarnej w !), Możesz uznać to badziewie za wektor (to tak naprawdę quat na temat tego, co ludzie mogliby nazwać równikiem sfery S3, która jest sferą S2! ! - zginanie rzeczy, jeśli weźmiemy pod uwagę fakt, że ludzie w XIX wieku upośledzeni technicznie wydają się nam w dzisiejszych czasach kowbojami EyePhone). Hamilton przyjął ten wektor w swojej quat: v=(0,x,y,z)przeprowadził serię eksperymentów, biorąc pod uwagę właściwości geometryczne quatów. Krótko mówiąc:

INPUT: _v=(x,y,z)_ a random 3D vector to rotate about an __u__ unit axis by an angle of _theta_

OUTPUT: q*(0,_v_)*conjugate(q)

gdzie

 q = (cos(theta/2), sin(theta/2)*u)
 conjugate(q) = inverse(q) = (cos(theta/2), -sin(theta/2)*u)
 norm(q)=magnitude(q)=|q|=1

Uwaga: sprzężenie q * (0, v) * (q) musi być kolejnym quatem formy (0, v '). Nie będę omawiał tego pozornie skomplikowanego wyjaśnienia, dlaczego tak się dzieje, ale jeśli obrócisz za pomocą tej metody czysty wyimaginowany czwartorzęd (lub w naszym przypadku wektor!), Musisz uzyskać podobny rodzaj przedmiotu: czysty wyimaginowany quat. i bierzesz jego wymyśloną część jako wynik. Oto wspaniały świat rotacji z czwartorzędami w łupinie orzecha (ty).

UWAGA : ktokolwiek wskakuje z tą nadużywaną frazą: quaty są dobre, ponieważ unikają blokady gimbala ... powinni najpierw odblokować swoją wyobraźnię !! Quaty są jedynie „eleganckim” aparatem matematycznym, którego można całkowicie uniknąć, stosując inne podejścia, przy czym moim zdaniem całkowicie geometrycznie równoważne jest podejście do kąta osi.

KOD : biblioteka C ++, którą według mnie jest dość uproszczona, ale ma wszystkie operacje na matrycy, wektorze i quatach, których powinien potrzebować eksperymentator grafiki 3D bez konieczności marnowania więcej niż 15 minut na naukę. Za pomocą tego możesz przetestować to, co tu napisałem w 15 minut, jeśli nie jesteś nowicjuszem w C ++. Powodzenia!

Oto alternatywny sposób transformacji wektora o czwartorzędu. Jest to sposób, w jaki MS robi to w środowisku xna. http://pastebin.com/fAFp6NnN

Próbowałem to rozwiązać ręcznie i wymyśliłem następujące równanie / metodę:

// inside quaterion class
// quaternion defined as (r, i, j, k)
Vector3 rotateVector(const Vector3 & _V)const{
    Vector3 vec();   // any constructor will do
    vec.x = 2*(r*_V.z*j + i*_V.z*k - r*_V.y*k + i*_V.y*j) + _V.x*(r*r + i*i - j*j - k*k);
    vec.y = 2*(r*_V.x*k + i*_V.x*j - r*_V.z*i + j*_V.z*k) + _V.y*(r*r - i*i + j*j - k*k);
    vec.z = 2*(r*_V.y*i - r*_V.x*j + i*_V.x*k + j*_V.y*k) + _V.z*(r*r - i*i - j*j + k*k);
    return vec;
}

Byłbym wdzięczny, gdyby ktoś spojrzał na pochodzenie mt, którego użyłem http://pastebin.com/8QHQqGbv Sugerowałbym skopiowanie do edytora tekstowego, który obsługuje przewijanie boczne

w mojej notacji użyłem q ^ (- 1), aby oznaczać koniugat, a nie odwrotność i różne identyfikatory, ale mam nadzieję, że można go śledzić. Myślę, że większość ma rację, szczególnie gdy udowadnianie, że prawdziwa część wektora zniknie.