การหมุนเวกเตอร์ 3 โดยควอเทอเนียน

ฉันพยายามหมุนเวกเตอร์ 3 ด้วย quaternion ที่กำหนด

ฉันรู้ว่านี่เป็นเรื่องจริง

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

ฉันรู้ว่าเป็นสิ่งที่ตรงกันข้ามที่แต่ฉันจะแมปการคูณเวกเตอร์กับควอเทอเรียนเพื่อกลับเวกเตอร์ได้อย่างไร?$q^{-1}$$\frac {-q} {magnitude(q)}$

ฉันได้พบว่าคุณสามารถปฏิบัติต่อเป็นเมทริกซ์และแปลงและเป็นเมทริกซ์แล้วแปลงจากเมทริกซ์เป็นเวกเตอร์ได้ แต่นี่ดูเหมือนจะน้อยกว่าด้านบนเพื่อรับเวกเตอร์ มีการนำไปใช้ที่สะอาดกว่าที่ฉันสามารถใช้ได้หรือไม่?$v$$q$$q'$$v'$

เมื่อ Nathan Reed และ Teodron เปิดเผยสูตรการหมุนเวกเตอร์vโดยหน่วย quaternion ความยาวหน่วยqคือ:

1) การสร้าง quaternion บริสุทธิ์Pออกมาจากโวลต์ นี่หมายถึงการเพิ่มพิกัดที่สี่เป็น 0:

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

2) pre-multiply ด้วยqและ post-multiply ด้วย conjugate q * :

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

3) สิ่งนี้จะส่งผลให้เกิด quaternion บริสุทธิ์อีกอันซึ่งสามารถกลับไปเป็นเวกเตอร์ได้:

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

นี้เวกเตอร์เป็นหมุนโดยQ$v'$$v$$q$

---

นี้คือการทำงาน แต่ไกลจากที่ดีที่สุด การคูณแบบควอเทอเรียนหมายถึงการปฏิบัติงานเป็นตันและตัน ฉันอยากรู้เกี่ยวกับการใช้งานที่หลากหลายเช่นอันนี้และตัดสินใจที่จะหาจากที่มาเหล่านั้น นี่คือสิ่งที่ฉันค้นพบ

นอกจากนี้เรายังสามารถอธิบายqเป็นการรวมกันของเวกเตอร์ 3 มิติuและ scalar s :

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

ตามกฎของการคูณ quaternionและเมื่อการรวมกันของความยาวหน่วย quaternion เป็นเพียงการผกผันเราจะได้รับ:

$$\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}$$

ส่วนที่สเกลาร์ (วงรี) ผลลัพธ์ในศูนย์ตามรายละเอียดที่นี่ สิ่งที่น่าสนใจเป็นส่วนหนึ่งเวกเตอร์อาคาหมุนเวกเตอร์ของเราV' สามารถทำให้ง่ายขึ้นโดยใช้ข้อมูลเฉพาะตัวของเวกเตอร์พื้นฐาน :

$$\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}$$

นี่เป็นสิ่งที่ดีที่สุดแล้ว สองผลิตภัณฑ์ดอทผลิตภัณฑ์แบบไขว้และความพิเศษอื่น ๆ : ประมาณครึ่งหนึ่งของการปฏิบัติการ ซึ่งจะให้อะไรเช่นนั้นในซอร์สโค้ด (สมมติว่ามีห้องสมุดคณิตศาสตร์เวกเตอร์ทั่วไป):

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);
}

ก่อนอื่น q ^ (- 1) ไม่ใช่ -q / magnitude (q); มันคือ q * / (ขนาด (q)) ^ 2 (q * คือคอนจูเกตซึ่งทำให้ส่วนต่าง ๆ ทั้งหมดยกเว้นของจริง) แน่นอนคุณสามารถละทิ้งการแบ่งตามขนาดถ้า quaternions ทั้งหมดของคุณเป็นปกติแล้วซึ่งพวกเขามักจะอยู่ในระบบการหมุน

สำหรับการคูณด้วยเวกเตอร์คุณแค่ขยายเวกเตอร์ไปเป็นควอเทอเนียนด้วยการตั้งค่าองค์ประกอบที่แท้จริงของ quat ให้เป็นศูนย์และส่วนประกอบ ijk เป็น xyz ของเวกเตอร์ จากนั้นคุณทำการคูณควอเทอเนียนชันเพื่อหา v 'แล้วแยกส่วนประกอบ ijk อีกครั้ง (ส่วนที่แท้จริงของ v 'ควรออกมาเป็นศูนย์เสมอบวกหรือลบข้อผิดพลาดบางจุดลอยตัว)

การสังเกตครั้งแรก: การผกผันของqไม่ใช่ความ-q/magnitude(q)ผิดทั้งหมด การหมุนที่มีควอเทอร์นอสบ่งบอกว่าจำนวนเชิงซ้อนจำนวน 4D ที่ซับซ้อนเหล่านี้มีบรรทัดฐานรวมกันดังนั้นจึงอยู่ในทรงกลมของหน่วย S3 ในพื้นที่ 4D นั้น ความจริงที่ว่า quat นั้นเป็นแบบรวมหมายความว่าบรรทัดฐานของมันคือnorm(q)^2=q*conjugate(q)=1และนั่นหมายความว่าสิ่งที่ตรงกันข้ามของ quat นั้นคือการผันคำกริยา

หากหน่วย quaternion เขียนเป็นq=(w,x,y,z)= (cos (t), sin (t) v ) ดังนั้นคอนจูเกตของมันคือconjugate(q)=(w,-x,-y,-z)= (cos (t), - sin (t) v ) โดยที่tคือครึ่งหนึ่งของมุมการหมุนและvคือแกนหมุน (แน่นอนว่าเป็นเวกเตอร์หน่วย)

เมื่อแฮมิลตันเพื่อนคนนั้นตัดสินใจที่จะเล่นด้วยจำนวนที่ซับซ้อนเทียบเท่าในมิติที่สูงขึ้นเขาก็สะดุดกับคุณสมบัติที่ดีบางอย่าง ตัวอย่างเช่นถ้าคุณจ้างควอเทอเนียนที่บริสุทธิ์q=(0,x,y,z)(ไม่มีสเกลาร์ส่วนที่w !) คุณสามารถพิจารณาอึนั้นว่าเป็นเวกเตอร์ (อันที่จริงแล้วมันคือสิ่งที่ผู้คนอาจเรียกว่าเส้นศูนย์สูตรของทรงกลม S3) ! - ใจงอสิ่งต่าง ๆ ถ้าเราพิจารณาว่าผู้คนที่มีความบกพร่องทางเทคนิคในศตวรรษที่ 19 ดูเหมือนจะมองดูว่าเรามีการเลี้ยงวัวด้วยตาแล้วในปัจจุบัน) แฮมิลตันจึงเอาเวกเตอร์นั้นมาในรูปแบบ quat: v=(0,x,y,z)และทำการทดลองหลายครั้งโดยพิจารณาคุณสมบัติทางเรขาคณิตของ quats .. เรื่องสั้นสั้น ๆ :

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)

ที่ไหน

 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

การสังเกต: q * (0, v) * conj (q) จะต้องเป็นอีก quat ของแบบฟอร์ม (0, v ') ฉันจะไม่อธิบายทุกอย่างที่ซับซ้อนว่าทำไมสิ่งนี้ถึงเกิดขึ้น แต่ถ้าคุณหมุน quaternion จินตภาพบริสุทธิ์ (หรือเวกเตอร์ในกรณีของเรา!) ด้วยวิธีนี้คุณต้องได้วัตถุที่คล้ายกัน: quat จินตภาพบริสุทธิ์ และคุณใช้ส่วนจินตภาพเป็นผลลัพธ์ของคุณ ที่นั่นคุณมีแล้วโลกแห่งการหมุนรอบที่ยอดเยี่ยมพร้อมกับควอเทอร์เนียนในเปลือกหอย (ty)

หมายเหตุ : ใครก็ตามที่กระโดดด้วยวลีที่ใช้มากเกินไป: quats นั้นดีเพราะพวกเขาหลีกเลี่ยง 'em gimbal lock .. ควรปลดล็อคจินตนาการของพวกเขาก่อน !! Quats เป็นเพียงเครื่องมือทางคณิตศาสตร์ที่ "สวยงาม" และสามารถหลีกเลี่ยงได้ทั้งหมดโดยใช้วิธีการอื่น ๆ อย่างใดอย่างหนึ่งที่ฉันพบว่ามีความเท่าเทียมกันทางเรขาคณิตอย่างสมบูรณ์เป็นแนวทางมุมของแกน

CODE : ไลบรารี่C ++ ที่ฉันนึกฝันง่าย แต่มีเมทริกซ์เวคเตอร์และการดำเนินการ quat ที่ผู้ทดลองใช้กราฟิก 3 มิติควรใช้โดยไม่ต้องเสียเวลาเรียนมากกว่า 15 นาที .. คุณสามารถทดสอบสิ่งที่ฉันเขียนที่นี่โดยใช้สิ่งนั้น ใน 15 นาทีถ้าคุณไม่ใช่มือใหม่ C ++ โชคดี!

นี่คือวิธีทางเลือกในการแปลงเวคเตอร์โดยควอเทอเนียน มันเป็นวิธีที่ MS ทำในกรอบ xna http://pastebin.com/fAFp6NnN

ฉันพยายามทำสิ่งนี้ด้วยมือและเกิดขึ้นกับสมการ / วิธีการต่อไปนี้:

// 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;
}

ฉันจะขอบคุณถ้ามีใครบางคนจะมองไปที่ mt derivatiion ฉันใช้http://pastebin.com/8QHQqGbvฉันขอแนะนำให้คัดลอกไปยังโปรแกรมแก้ไขข้อความที่รองรับการเลื่อนด้านข้าง

ในสัญกรณ์ของฉันฉันใช้ q ^ (- 1) เพื่อหมายถึงคอนจูเกตและไม่ผกผันและตัวระบุที่แตกต่างกัน แต่ฉันหวังว่ามันจะสามารถติดตามได้ ฉันคิดว่าส่วนใหญ่ถูกต้องโดยเฉพาะที่การพิสูจน์ส่วนที่แท้จริงของเวกเตอร์จะหายไป