क्या क्वाटरनियन रोटेशन को यूलर कोण रोटेशन में परिवर्तित करने के लिए कोई एल्गोरिदम है?

Question

वहाँ एक यूलर कोण प्रतिनिधित्व करने के लिए एक रोटेशन के एक चौका प्रतिनिधित्व परिवर्तित करने के लिए एक मौजूदा एल्गोरिथ्म है? यूलर प्रतिनिधित्व के लिए रोटेशन के क्रम में जाना जाता है और छह क्रमपरिवर्तन से कोई भी हो सकता है (यानी xyz, XZY, yxz, YZX, zxy, zyx)। मैंने एक निश्चित रोटेशन ऑर्डर (आमतौर पर नासा शीर्षक, बैंक, रोल सम्मेलन) के लिए एल्गोरिदम देखा है, लेकिन मनमाने ढंग से रोटेशन ऑर्डर के लिए नहीं।

इसके अलावा, एक भी उन्मुखीकरण के कई यूलर कोण अभ्यावेदन देखते हैं क्योंकि, इस परिणाम अस्पष्ट होने जा रहा है। यह स्वीकार्य है, (क्योंकि उन्मुखीकरण अभी भी वैध है, यह सिर्फ एक नहीं उपयोगकर्ता देखने की उम्मीद कर रहा है हो सकता है), लेकिन यह अगर वहाँ एक एल्गोरिथ्म जो रोटेशन सीमा ले लिया (यानी की डिग्री की संख्या था यहां तक ​​कि बेहतर होगा स्वतंत्रता और आजादी की प्रत्येक डिग्री पर सीमाएं) खाते में और उन बाधाओं को 'सबसे समझदार' यूलर प्रतिनिधित्व प्रदान किया।

मुझे लगता है इस समस्या को (या कुछ इसी तरह) इंद्रकुमार या कठोर शरीर गतिशीलता डोमेन में मौजूद हो सकता है है।

---

हल: मैं सिर्फ महसूस किया कि यह स्पष्ट नहीं हो सकता है कि मैं ग्राफिक्स रत्न से केन Shoemake के एल्गोरिदम का पालन करते हुए इस समस्या का समाधान। मैंने उस समय अपने स्वयं के प्रश्न का उत्तर दिया, लेकिन यह मेरे लिए होता है यह स्पष्ट नहीं हो सकता कि मैंने ऐसा किया। अधिक जानकारी के लिए, नीचे, उत्तर देखें।

---

बस स्पष्ट करने के लिए - मैं क्या 'नासा' सम्मेलन बुला रहा था - मैं कैसे एक चौका से तथाकथित 'Tait-Bryan' प्रतिनिधित्व करने के लिए कन्वर्ट करने के लिए पता है। यह एक रोटेशन ऑर्डर है (इस सम्मेलन को मानते हुए कि 'जेड' अक्ष ऊपर है) zxy का। मुझे सभी रोटेशन ऑर्डर के लिए एल्गोरिदम चाहिए।

संभवतः समाधान है, तो, zxy आदेश रूपांतरण लेते हैं और इसे से अन्य रोटेशन के आदेश के लिए पांच अन्य रूपांतरण प्राप्त करने के लिए है। मुझे लगता है कि मैं उम्मीद कर रहा था कि एक और 'अतिव्यापी' समाधान था। किसी भी मामले में, मुझे हैरान है कि मैं वहां मौजूद मौजूदा समाधान नहीं ढूंढ पा रहा हूं।

इसके अतिरिक्त, और शायद यह एक अलग प्रश्न होना चाहिए, किसी भी रूपांतरण (निश्चित रूप से एक ज्ञात रोटेशन ऑर्डर मानना) एक यूलर प्रतिनिधित्व का चयन करने जा रहा है, लेकिन वास्तव में बहुत से लोग हैं। उदाहरण के लिए, yxz का रोटेशन ऑर्डर दिया गया है, दो प्रस्तुतियां (0,0,180) और (180,180,0) बराबर हैं (और समान क्वाटरनियन उत्पन्न करेंगी)। स्वतंत्रता की डिग्री पर सीमा का उपयोग कर समाधान को रोकने का कोई तरीका है? जैसे आप आईके और कठोर शरीर गतिशीलता में करते हैं? यानी ऊपर दिए गए उदाहरण में यदि ज़ेड अक्ष के बारे में केवल एक डिग्री की आजादी थी तो दूसरा प्रतिनिधित्व अवहेलना किया जा सकता है।

---

मैं एक कागज जो this pdf में एक एल्गोरिथ्म हो सकता है नीचे नज़र रखी है, लेकिन मैं कबूल मैं तर्क और गणित एक छोटे से कठिन पालन करने के लिए लगता है। निश्चित रूप से वहाँ अन्य समाधान हैं? मनमाने ढंग से घूर्णन आदेश वास्तव में इतना दुर्लभ है? निश्चित रूप से प्रत्येक प्रमुख 3 डी पैकेज जो कंकाल एनीमेशन (यानी माया, मैक्स, ब्लेंडर इत्यादि) के साथ कंकाल एनीमेशन को एक साथ ठीक करने की अनुमति देता है?

Answer 1

यह पुरानी प्रौद्योगिकी के एक क्लासिक मामले की तरह लग रहा अनदेखी की जा रही है - मैं ग्राफिक्स रत्न की एक प्रति की खुदाई करने में कामयाब गेराज से चतुर्थ और ऐसा लगता है जैसे केन शोमेक न केवल के यूलर कोणों से मनमाने ढंग से रोटेशन ऑर्डर के रूप में परिवर्तित करने के लिए एक एल्गोरिदम है, बल्कि इस विषय पर मेरे अन्य प्रश्नों का उत्तर भी देता है। किताबों के लिए हुरेय। अगर मैं केवल श्री शोमेक के जवाब को वोट दे सकता हूं और प्रतिष्ठा के साथ उन्हें पुरस्कृत कर सकता हूं।

मुझे लगता है कि यूलर कोणों के साथ काम करने वाले किसी भी व्यक्ति को अपनी स्थानीय पुस्तकालय से ग्राफिक्स जेम्स टाइम्स की एक प्रति प्राप्त करनी चाहिए और पेज 222 से शुरू होने वाले अनुभाग को पढ़ना होगा। इसे अभी तक पढ़ने वाली समस्या का सबसे स्पष्ट और सबसे संक्षिप्त स्पष्टीकरण होना चाहिए। http://www.cgafaq.info/wiki/Euler_angles_from_matrix - -

---

यहाँ एक उपयोगी लिंक मैं के बाद से पाया है है यह Shoemake रूप में एक ही प्रणाली इस प्रकार; रोटेशन ऑर्डर के 24 अलग-अलग क्रमिकरण चार अलग-अलग पैरामीटर के रूप में एन्कोड किए जाते हैं - आंतरिक अक्ष, समानता, पुनरावृत्ति और फ्रेम - जो आपको 24 मामलों से एल्गोरिदम को कम करने की अनुमति देता है। सामान्य रूप से उपयोगी विकी हो सकता है - मैं नहीं आया था इससे पहले।

पुराना लिंक टूटा हुआ प्रतीत होता है here एक रोटेशन मैट्रिक्स से कंप्यूटिंग यूलर कोण "की एक और प्रति है।

Answer 2

Wikipedia दिखाता है कि आप चार का समुदाय के कुछ हिस्सों का उपयोग करें और यूलर कोण की गणना कर सकते हैं।

Answer 3

Z अक्ष के साथ एक दाएं हाथ के कार्तीय निर्देशांक प्रणाली में ऊपर की ओर रहे, ऐसा करते हैं:

struct Quaternion 
{ 
    double w, x, y, z; 
}; 

void GetEulerAngles(Quaternion q, double& yaw, double& pitch, double& roll) 
{ 
    const double w2 = q.w*q.w; 
    const double x2 = q.x*q.x; 
    const double y2 = q.y*q.y; 
    const double z2 = q.z*q.z; 
    const double unitLength = w2 + x2 + y2 + z2; // Normalised == 1, otherwise correction divisor. 
    const double abcd = q.w*q.x + q.y*q.z; 
    const double eps = 1e-7; // TODO: pick from your math lib instead of hardcoding. 
    const double pi = 3.14159265358979323846; // TODO: pick from your math lib instead of hardcoding. 
    if (abcd > (0.5-eps)*unitLength) 
    { 
     yaw = 2 * atan2(q.y, q.w); 
     pitch = pi; 
     roll = 0; 
    } 
    else if (abcd < (-0.5+eps)*unitLength) 
    { 
     yaw = -2 * ::atan2(q.y, q.w); 
     pitch = -pi; 
     roll = 0; 
    } 
    else 
    { 
     const double adbc = q.w*q.z - q.x*q.y; 
     const double acbd = q.w*q.y - q.x*q.z; 
     yaw = ::atan2(2*adbc, 1 - 2*(z2+x2)); 
     pitch = ::asin(2*abcd/unitLength); 
     roll = ::atan2(2*acbd, 1 - 2*(y2+x2)); 
    } 
} 

Answer 4

मैं noelhughes.net पर मेरी वेबसाइट पर "मनमानी रोटेशन अनुक्रम ज्यामितीय तरीके का उपयोग के लिए यूलर कोण रूपांतरण करने के लिए Quaternion" मेरे कागज शीर्षक से पोस्ट किया है। मेरे पास यूलर कोणों के किसी भी सेट को एक quaternion और quaternion को दिशा कोसाइन मैट्रिक्स से कनवर्ट करने के लिए एल्गोरिदम भी है जो मैं इस सप्ताह के अंत में पोस्ट करूंगा। ये मार्टिन बेकर्स वेबसाइट पर भी हैं, हालांकि खोजने में थोड़ा मुश्किल है। Google मेरा नाम, नोएल ह्यूजेस, और quaternions और आपको यह मिलना चाहिए।

चरण 1:: सुनिश्चित करें कि यूलर रोटेशन के लिए जो सम्मेलन आप चाहते हैं, कहते हैं बनाओ, zyx

Answer 5

मैं इसे इस तरह का समाधान।

चरण 2: रोटेशन के लिए विश्लेषणात्मक रोटेशन मैट्रिक्स की गणना करें। उदाहरण के लिए, आप आर (zyx), चाहते हैं, तो

** आर *** zyx * = ** आर *** एक्स * (फ़ाई) * ** आर *** y * (थीटा) * ** आर *** जेड * (साई), जहां तत्व बन

R11 = cos(theta)*cos(psi) 
R12 = -cos(theta)*sin(psi) 
R13 = sin(theta) 
R21 = sin(psi)*cos(phi) + sin(theta)*cos(psi)*sin(phi) 
R22 = cos(psi)*cos(phi) - sin(theta)*sin(psi)*sin(phi) 
R23 = -cos(theta)*sin(phi) 
R31 = sin(psi)*sin(phi) - sin(theta)*cos(psi)*cos(phi) 
R32 = cos(psi)sin(phi) + sin(theta)*sin(psi)*cos(phi) 
R33 = cos(theta)*cos(phi) 

चरण 3: निरीक्षण करके, आप का उपयोग कर तीन कोण के लिए पाप या भूरे पा सकते हैं उपरोक्त तत्व। इस उदाहरण में,

tan(phi) = -R23/R33 

sin(theta) = -R13 

tan(psi) = -R12/R11 

चरण 4: कंप्यूट अपने चार का समुदाय से रोटेशन मैट्रिक्स (wikipedia देखें), तत्वों आप 3 में के रूप में कोण की गणना करने) के ऊपर की जरूरत के लिए।

अन्य परंपराओं को उसी प्रक्रिया का उपयोग करके गणना की जा सकती है।

Answer 6

यहां एक पेपर है जिसे मैंने क्वाटरनियन को यूलर कोणों में बदलने पर लिखा था।

Link 1

मैं भी quaternions के विभिन्न पहलुओं पर चर्चा, यूलर कोण और रोटेशन मैट्रिक्स (DCM) इस स्थान पर दस्तावेजों के एक नंबर डाल दिया है।

Link 2

Answer 7

मैं एक ऐसी ही समाधान के लिए कई दिनों के लिए तलाश कर दिया गया है, और मैं अंत में इस वेबसाइट मनमाना यूलर और टैट-ब्रायन रोटेशन के लिए quaternions परिवर्तित करने के लिए एक एल्गोरिथ्म है कि भर में भाग गया!

यहाँ लिंक है: http://bediyap.com/programming/convert-quaternion-to-euler-rotations/

और यहाँ कोड है:

/////////////////////////////// 
// Quaternion to Euler 
/////////////////////////////// 
enum RotSeq{zyx, zyz, zxy, zxz, yxz, yxy, yzx, yzy, xyz, xyx, xzy,xzx}; 

void twoaxisrot(double r11, double r12, double r21, double r31, double r32, double res[]){ 
    res[0] = atan2(r11, r12); 
    res[1] = acos (r21); 
    res[2] = atan2(r31, r32); 
} 

void threeaxisrot(double r11, double r12, double r21, double r31, double r32, double res[]){ 
    res[0] = atan2(r31, r32); 
    res[1] = asin (r21); 
    res[2] = atan2(r11, r12); 
} 

void quaternion2Euler(const Quaternion& q, double res[], RotSeq rotSeq) 
{ 
    switch(rotSeq){ 
    case zyx: 
     threeaxisrot(2*(q.x*q.y + q.w*q.z), 
        q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
        -2*(q.x*q.z - q.w*q.y), 
        2*(q.y*q.z + q.w*q.x), 
        q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
        res); 
     break; 

    case zyz: 
     twoaxisrot(2*(q.y*q.z - q.w*q.x), 
        2*(q.x*q.z + q.w*q.y), 
        q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
        2*(q.y*q.z + q.w*q.x), 
        -2*(q.x*q.z - q.w*q.y), 
        res); 
     break; 

    case zxy: 
     threeaxisrot(-2*(q.x*q.y - q.w*q.z), 
         q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
         2*(q.y*q.z + q.w*q.x), 
        -2*(q.x*q.z - q.w*q.y), 
         q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
         res); 
     break; 

    case zxz: 
     twoaxisrot(2*(q.x*q.z + q.w*q.y), 
        -2*(q.y*q.z - q.w*q.x), 
        q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
        2*(q.x*q.z - q.w*q.y), 
        2*(q.y*q.z + q.w*q.x), 
        res); 
     break; 

    case yxz: 
     threeaxisrot(2*(q.x*q.z + q.w*q.y), 
        q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
        -2*(q.y*q.z - q.w*q.x), 
        2*(q.x*q.y + q.w*q.z), 
        q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
        res); 
     break; 

    case yxy: 
     twoaxisrot(2*(q.x*q.y - q.w*q.z), 
        2*(q.y*q.z + q.w*q.x), 
        q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
        2*(q.x*q.y + q.w*q.z), 
        -2*(q.y*q.z - q.w*q.x), 
        res); 
     break; 

    case yzx: 
     threeaxisrot(-2*(q.x*q.z - q.w*q.y), 
         q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
         2*(q.x*q.y + q.w*q.z), 
        -2*(q.y*q.z - q.w*q.x), 
         q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
         res); 
     break; 

    case yzy: 
     twoaxisrot(2*(q.y*q.z + q.w*q.x), 
        -2*(q.x*q.y - q.w*q.z), 
        q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
        2*(q.y*q.z - q.w*q.x), 
        2*(q.x*q.y + q.w*q.z), 
        res); 
     break; 

    case xyz: 
     threeaxisrot(-2*(q.y*q.z - q.w*q.x), 
        q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z, 
        2*(q.x*q.z + q.w*q.y), 
        -2*(q.x*q.y - q.w*q.z), 
        q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
        res); 
     break; 

    case xyx: 
     twoaxisrot(2*(q.x*q.y + q.w*q.z), 
        -2*(q.x*q.z - q.w*q.y), 
        q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
        2*(q.x*q.y - q.w*q.z), 
        2*(q.x*q.z + q.w*q.y), 
        res); 
     break; 

    case xzy: 
     threeaxisrot(2*(q.y*q.z + q.w*q.x), 
        q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z, 
        -2*(q.x*q.y - q.w*q.z), 
        2*(q.x*q.z + q.w*q.y), 
        q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
        res); 
     break; 

    case xzx: 
     twoaxisrot(2*(q.x*q.z - q.w*q.y), 
        2*(q.x*q.y + q.w*q.z), 
        q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z, 
        2*(q.x*q.z + q.w*q.y), 
        -2*(q.x*q.y - q.w*q.z), 
        res); 
     break; 
    default: 
     std::cout << "Unknown rotation sequence" << std::endl; 
     break; 
    } 
} 

Answer 8

उन है कि इस पेज पर आते हैं, जबकि Googling के लिए, मैं हाल ही में सभी 12 आंतरिक टैट-ब्रायन के लिए ये रूपांतरण के लिए derivations पाया (1-2-3, 3-2-1, आदि) और उचित यूलर (1-2-1, 3-1-3, आदि) के बाद दो संदर्भों में रोटेशन दृश्यों:

• NASA Paper, July 1977: Eule आर> डीसीएम, यूलर> Quaternion, डीसीएम> यूलर
• Birdy's Notebook, Oct 2013: Quaternion> यूलर दूसरी कड़ी के लिए frodo2975 करने के लिए

धन्यवाद।