दाएं हाथ से बाएं हाथ के समन्वय प्रणाली से एक मैट्रिक्स बदलना

Question

मैं दाएं हाथ से एक 4x4 मैट्रिक्स को बदलना चाहता हूं जहां:
एक्स बाएं और दाएं है, वाई आगे और पीछे है और z ऊपर और नीचे है
एक्स छोड़ दिया और सही है, z आगे और पीछे है और y ऊपर और नीचे है:

एक बाएं हाथ के प्रणाली है जहाँ के लिए

।

वेक्टर के लिए यह आसान है, बस वाई और जेड मानों को स्वैप करें, लेकिन आप इसे मैट्रिक्स के लिए कैसे करते हैं?

Answer 1

मुझे इसे थोड़ा बेहतर समझाने की कोशिश करें। मुझे ब्लेंडर से एक मॉडल निर्यात करने की आवश्यकता है, जिसमें जेड अक्ष का सामना ओपनजीएल में होता है, जहां वाई धुरी का सामना होता है।

प्रत्येक समन्वय (x, y, z) के लिए यह आसान है; बस वाई और जेड मानों को स्वैप करें: (एक्स, जेड, वाई)।
क्योंकि मैंने सभी वाई और जेड मानों को बदल दिया है, मेरे द्वारा उपयोग किए जाने वाले किसी भी मैट्रिक्स को भी फ़्लिप करने की आवश्यकता है ताकि इसका एक ही प्रभाव हो।

खोज रहा अंततः gamedev पर एक समाधान मिल गया है की एक बहुत कुछ करने के बाद:

अपने मैट्रिक्स इस तरह दिखाई देता है:

{ rx, ry, rz, 0 } 
{ ux, uy, uz, 0 } 
{ lx, ly, lz, 0 } 
{ px, py, pz, 1 } 

सही करने के लिए या बाएं से दाएं बाएं से यह बदलने के लिए, फ्लिप यह इस तरह है:

{ rx, rz, ry, 0 } 
{ lx, lz, ly, 0 } 
{ ux, uz, uy, 0 } 
{ px, pz, py, 1 } 

Answer 2

चूंकि यह होमवर्क उत्तर जैसा लगता है; मैं आपको एक संकेत पर एक शुरुआत दूंगा: मैट्रिक्स नकारात्मक के निर्धारक को बनाने के लिए आप क्या कर सकते हैं?

आगे (बेहतर संकेत): चूंकि आप पहले से ही जानते हैं कि व्यक्तिगत वैक्टरों के साथ उस परिवर्तन को कैसे करना है, क्या आपको नहीं लगता कि आप इसे वैक्टर के आधार पर करने में सक्षम होंगे जो मैट्रिक्स के रूपांतरण को दर्शाता है? (याद रखें कि एक मैट्रिक्स को यूनिट वैक्टर के टुपल पर किए गए रैखिक ट्रांसर्मेशन के रूप में देखा जा सकता है)

Answer 3

यह निर्भर करता है कि क्या आप बाएं या दाएं से मैट्रिक्स को गुणा करके अपने अंक बदलते हैं।

यदि आप बाएं से गुणा करते हैं (उदा: एक्स = एक्स ', जहां ए एक मैट्रिक्स और एक्स' रूपांतरित बिंदु है), तो आपको केवल दूसरे और तीसरे कॉलम को स्वैप करने की आवश्यकता है। यदि आप दाएं से गुणा करते हैं (उदा: xA = x '), तो आपको दूसरी और तीसरी पंक्ति स्वैप करने की आवश्यकता है।

यदि आपके अंक कॉलम वैक्टर हैं तो आप पहले परिदृश्य में हैं।

Answer 4

मुझे लगता है कि मैं आपकी समस्या को समझते हैं क्योंकि मैं वर्तमान में इसी तरह की एक का सामना करना पड़ रहा है।

• आप एक दुनिया मैट्रिक्स जो एक जगह है जहाँ जेड निर्भर है (उदाहरण के लिए एक विश्व मैट्रिक्स) में एक वेक्टर बदल देती है के साथ शुरू करते हैं।

• अब आपके पास एक जगह है जहां वाई ऊपर है और आप जानना चाहते हैं कि अपने पुराने मैट्रिक्स के साथ क्या करना है।

इस प्रयास करें:

किसी दिए गए दुनिया मैट्रिक्स

Matrix world = ... //space where Z is up 

इस मैट्रिक्स में परिवर्तन आप इस के लिए खोज रहे हैं एक वेक्टर

Matrix mToggle_YZ = new Matrix(
{1, 0, 0, 0} 
{0, 0, 1, 0} 
{0, 1, 0, 0} 
{0, 0, 0, 1}) 

की Y और Z घटक नहीं है :

//same world transformation in a space where Y is up 
Matrix world2 = mToggle_YZ * world * mToggle_YZ; 

परिणाम नीचे पोस्ट किया गया वही मैट्रिक्स cmann है। लेकिन मुझे लगता है यह और अधिक समझ में आता है के रूप में यह निम्नलिखित गणना को जोड़ती है:

1) वाई स्विच और जेड

2) वर्ष परिवर्तन

3 करो) स्विच वापस जेड और वाई

Answer 5

बदलें सही और बाएं हाथ के बीच समन्वय रिक्त स्थान स्वैप करने के लिए पाप कारक

Answer 6

मैं यूनिटी स्टीमवीआर_यूटिल्स को रेजिडट्रांसफॉर्म को आरओएस ज्यामित्री_एमएसजी/पॉज़ में परिवर्तित करने पर काम कर रहा हूं और एकता बाएं हाथ समन्वय प्रणाली को परिवर्तित करने की आवश्यकता है आरओएस दाहिनी ओर समन्वय प्रणाली सौंपी।

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

var device = SteamVR_Controller.Input(index); 
// Modify the unity controller to be in the same coordinate system as ROS. 
Vector3 ros_position = new Vector3(
    device.transform.pos.z, 
    -1 * device.transform.pos.x, 
    device.transform.pos.y); 
Quaternion ros_orientation = new Quaternion(
    -1 * device.transform.rot.z, 
    device.transform.rot.x, 
    -1 * device.transform.rot.y, 
    device.transform.rot.w); 

मूल रूप से मैंने @bleater से मैट्रिक्स उदाहरण का उपयोग करने का प्रयास किया, लेकिन मुझे इसे काम करने के लिए प्रतीत नहीं होता। जानना अच्छा लगेगा कि मैंने कहीं गलती की है या नहीं।

HmdMatrix44_t m = device.transform.ToHmdMatrix44(); 
HmdMatrix44_t m2 = new HmdMatrix44_t(); 
m2.m = new float[16]; 
// left -> right 
m2.m[0] = m.m[0]; m2.m[1] = m.m[2]; m2.m[2] = m.m[1]; m2.m[3] = m.m[3]; 
m2.m[4] = m.m[8]; m2.m[5] = m.m[10]; m2.m[6] = m.m[9]; m2.m[7] = m.m[7]; 
m2.m[8] = m.m[4]; m2.m[9] = m.m[6]; m2.m[10] = m.m[5]; m2.m[11] = m.m[11]; 
m2.m[12] = m.m[12]; m2.m[13] = m.m[14]; m2.m[14] = m.m[13]; m2.m[15] = m.m[15]; 

SteamVR_Utils.RigidTransform rt = new SteamVR_Utils.RigidTransform(m2); 

Vector3 ros_position = new Vector3(
    rt.pos.x, 
    rt.pos.y, 
    rt.pos.z); 
Quaternion ros_orientation = new Quaternion(
    rt.rot.x, 
    rt.rot.y, 
    rt.rot.z, 
    rt.rot.w); 

Answer 7

यह अक्सर मामला है कि आप आगे के एक सेट से एक मैट्रिक्स को बदलना चाहते हैं/सही/ऊपर सम्मेलनों आगे/सही/ऊपर सम्मेलनों का एक और सेट है। उदाहरण के लिए, आरओएस जेड-अप का उपयोग करता है, और अवास्तविक वाई-अप का उपयोग करता है। प्रक्रिया काम करती है कि आपको एक सौहार्द-फ्लिप करने की आवश्यकता है या नहीं।

ध्यान दें कि वाक्यांश "दाएं हाथ से बाएं हाथ से स्विच" अस्पष्ट है। कई बाएं हाथ के आगे/दाएं/ऊपर सम्मेलन हैं। उदाहरण के लिए: आगे = z, दाएं = एक्स, ऊपर = वाई; और आगे = एक्स, दाएं = वाई, ऊपर = जेड। आपको वास्तव में इसके बारे में "" के बारे में सोचना चाहिए, मैं आरओएस की अगली/दाएं/ऊपर की अवास्तविक धारणा को आगे/दाएं/ऊपर "के रूप में कैसे परिवर्तित करूं?

तो, यह एक मैट्रिक्स बनाने के लिए एक सीधा काम है जो सम्मेलनों के बीच परिवर्तित होता है। के मान लेते हैं कि हम उस किया है और अब हम

mat4x4 unrealFromRos = /* construct this by hand */; 
mat4x4 rosFromUnreal = unrealFromRos.inverse(); 

है चलो कहते हैं कि ओपी एक मैट्रिक्स है कि आरओएस से आता है, और वह अवास्तविक में इसका इस्तेमाल करना चाहता है। उसका मूल मैट्रिक्स एक आरओएस-स्टाइल वेक्टर लेता है, इसमें कुछ सामान होता है, और एक आरओएस-शैली वेक्टर उत्सर्जित करता है। उसे एक मैट्रिक्स की आवश्यकता होती है जो एक अवास्तविक-शैली वेक्टर लेता है, वही सामान करता है, और एक अवास्तविक-शैली वेक्टर उत्सर्जित करता है। ऐसा लगता है:

mat4x4 turnLeft10Degrees_ROS = ...; 
mat4x4 turnLeft10Degrees_Unreal = unrealFromRos * turnLeft10Degrees_ROS * rosFromUnreal; 

यह स्पष्ट होना चाहिए कि यह क्यों काम करता है। आप एक अवास्तविक वेक्टर लेते हैं, इसे आरओएस-शैली में परिवर्तित करते हैं, और अब आप उस पर आरओएस-स्टाइल मैट्रिक्स का उपयोग कर सकते हैं। यह आपको एक आरओएस वेक्टर देता है, जिसे आप वापस अवास्तविक शैली में बदल देते हैं।

गेरिट का जवाब बिल्कुल सामान्य नहीं है, क्योंकि सामान्य मामले में, rosFromUnreal! = UnrealFromRos। यह सच है यदि आप केवल एक अक्ष को बदल रहे हैं, लेकिन यदि आप एक्स-> वाई, वाई-> जेड, जेड-> एक्स को परिवर्तित करने की तरह कुछ कर रहे हैं तो सच नहीं है। मैंने पाया है कि यह हमेशा एक सही मैट्रिक्स का उपयोग करने के लिए कम त्रुटि प्रवण है और इन सम्मेलन स्विच करने के विपरीत है, बजाय सही सदस्यों को फ़्लिप करने वाले विशेष कार्यों को लिखने की कोशिश करने के बजाय।

इस प्रकार का मैट्रिक्स ऑपरेशन inverse(M) * X * M बहुत कुछ आता है। आप इसे "आधार परिवर्तन" ऑपरेशन के रूप में सोच सकते हैं; इसके बारे में और जानने के लिए, https://en.wikipedia.org/wiki/Matrix_similarity देखें।