प्रविष्टि

यह मुझे लगता है कि हमें कंप्यूटर ग्राफिक्स में कम त्रिकोणमिति का उपयोग करने की आवश्यकता है। अनुमानों, प्रतिबिंबों और वेक्टर ऑपरेशनों की एक अच्छी समझ (जैसा कि स्केलर (डॉट) का सही अर्थ है) और वेक्टर (क्रॉस) वैक्टर के उत्पाद आमतौर पर त्रिकोणमिति का उपयोग करते समय चिंता की बढ़ती भावना के साथ आते हैं। अधिक सटीक रूप से, मेरा मानना ​​है कि एल्गोरिथ्म में डेटा दर्ज करने के लिए त्रिकोणमिति अच्छा है (कोणों की अवधारणा के लिए, यह अभिविन्यास को मापने का एक सहज तरीका है), मुझे लगता है कि कुछ गलत है जब मैं त्रिकोणमिति को कुछ 3 डी रेंडरिंग एल्गोरिथ्म की गहराई में स्थित देखता हूं। वास्तव में, मुझे लगता है कि कहीं एक बिल्ली का बच्चा मर जाता है जब वहाँ त्रिकोणमिति रेंगता है। और मैं गति या सटीकता के बारे में चिंतित नहीं हूं, लेकिन वैचारिक लालित्य के साथ, मुझे लगता है ... अब मैं समझाऊंगा।

अन्य स्थानों पर, मैंने पहले ही चर्चा की है कि वैक्टर के स्केलर और वेक्टर उत्पादों में घुमाव के लिए सभी आवश्यक जानकारी होती है, उन दो "आयताकार" संचालन के लिए - कोणों की खान और कोसाइन। यह जानकारी इतनी बड़ी संख्या में साइन और कॉज़नेस के बराबर है कि ऐसा लगता है कि आप बस वैक्टर के उत्पाद का उपयोग कर सकते हैं और त्रिकोणमिति और कोणों से छुटकारा पा सकते हैं। व्यवहार में, आप साधारण यूक्लिडियन वैक्टर में रहकर ऐसा कर सकते हैं, बिना त्रिकोणमिति के। यह आपको आश्चर्यचकित करता है: "क्या हम कुछ अतिरिक्त नहीं कर रहे हैं?" करने लगता है। हालांकि, दुर्भाग्य से, यहां तक ​​कि अनुभवी पेशेवरों को त्रिकोणमिति का दुरुपयोग करने और चीजों को बहुत जटिल, बोझिल बनाने और सबसे संक्षिप्त नहीं होने का खतरा है। और संभवतः "गलत" भी।

आइए लेख को और भी अमूर्त बनाना बंद करें। आइए हम वेक्टर उत्पादों के साथ त्रिकोणमितीय सूत्रों को बदलने के मामलों में से एक की कल्पना करें और देखें कि मैंने अभी क्या बात की है।

किसी स्थान या वस्तु को घुमाने का गलत विकल्प

हमारे पास एक फ़ंक्शन है जो सामान्य वेक्टर के चारों ओर एक वेक्टर के रोटेशन मैट्रिक्स की गणना करता है $$$\ vec {v}$कोने पर $$$एक$। किसी भी 3 डी इंजन या रियल-टाइम गणित पुस्तकालय में, एक ऐसा फ़ंक्शन होगा जो किसी अन्य इंजन से विकिपीडिया या ओपनगैल ट्यूटोरियल की सबसे अधिक संभावना है, कॉपी किया जाता है ... (हां, इस बिंदु पर आपको स्वीकार करना होगा, और आपके मूड के आधार पर, यह चिंता करना संभव है। इस कारण)।

समारोह कुछ इस तरह दिखेगा:

mat3x3 rotationAxisAngle( const vec3 & v, float a ) { const float si = sinf( a ); const float co = cosf( a ); const float ic = 1.0f - co; return mat3x3( vx*vx*ic + co, vy*vx*ic - si*vz, vz*vx*ic + si*vy, vx*vy*ic + si*vz, vy*vy*ic + co, vz*vy*ic - si*vx, vx*vz*ic - si*vy, vy*vz*ic + si*vx, vz*vz*ic + co ); } 

कल्पना करें कि आप डेमो या गेम के इनसाइड के माध्यम से खुदाई कर रहे हैं, संभवतः किसी प्रकार के एनीमेशन मॉड्यूल को पूरा कर रहे हैं, और आपको किसी दिए गए दिशा में ऑब्जेक्ट को घुमाने की आवश्यकता है। आप इसे घुमाना चाहते हैं ताकि इसकी एक कुल्हाड़ी, कहें, एक धुरी $$$\ vec {z}$एक विशिष्ट वेक्टर के साथ मेल खाता है $$$\ vec {d}$, एनीमेशन पथ के स्पर्शरेखा। आप निश्चित रूप से, एक मैट्रिक्स बनाने का निर्णय लेते हैं जिसमें rotationAxisAngle() का उपयोग करके परिवर्तन शामिल होंगे। तो, आपको पहले अक्ष के बीच के कोण को मापने की आवश्यकता होगी $$$z$अपनी वस्तु और वांछित अभिविन्यास वेक्टर। चूंकि आप एक ग्राफिक प्रोग्रामर हैं, आप जानते हैं कि यह एक अदिश उत्पाद के साथ किया जा सकता है और फिर acos() साथ कोण को acos() ।

$$

$$\ vec {a} \ cdot \ vec {b} = a_xb_x + a_yb_y = ab \ cos {\ angle \ vec {a} \ vec {b}}$$

इसके अलावा, आप जानते हैं कि कभी-कभी acosf() अजीब मान लौटा सकता है यदि स्केलर उत्पाद सीमा [-1] के बाहर हो; 1], और आप इसके मूल्य को बदलने का निर्णय लेते हैं ताकि यह इस श्रेणी में आता है ( लगभग प्रति। क्लैंप के लिए) (इस बिंदु पर आप अपने कंप्यूटर की सटीकता को दोष देने की हिम्मत भी कर सकते हैं, क्योंकि सामान्यीकृत वेक्टर की लंबाई बिल्कुल 1 नहीं है)। इस बिंदु पर, एक बिल्ली का बच्चा मर गया। लेकिन जब तक आप इसके बारे में नहीं जानते, तब तक आप अपना कोड लिखना जारी रखेंगे। अगला, आप रोटेशन अक्ष की गणना करते हैं, और आप जानते हैं कि यह एक वेक्टर का एक वेक्टर उत्पाद है $$$\ vec {z}$अपनी वस्तु और चुनी हुई दिशा $$$\ vec {d}$, आपकी वस्तु के सभी बिंदु इन दोनों वैक्टरों द्वारा परिभाषित विमानों के समान घूमेंगे, बस मामले में ... (बिल्ली का बच्चा पुनर्जीवित हुआ और फिर से मारा गया)। नतीजतन, कोड कुछ इस तरह दिखता है:

 const vec3 axi = normalize( cross( z, d ) ); const float ang = acosf( clamp( dot( z, d ), -1.0f, 1.0f ) ); const mat3x3 rot = rotationAxisAngle( axi, ang ); 

यह समझने के लिए कि यह क्यों काम करता है, लेकिन फिर भी त्रुटिपूर्ण रूप से, हम सभी rotationAxisAngle() को खोल देंगे rotationAxisAngle() कोड देखें और वास्तव में देखें:

 const vec3 axi = normalize( cross( z, d ) ); const float ang = acosf( clamp( dot( z, d ), -1.0f, 1.0f ) ); const float co = cosf( ang ); const float si = sinf( ang ); const float ic = 1.0f - co; const mat3x3 rot = mat3x3( axi.x*axi.x*ic + co, axi.y*axi.x*ic - si*axi.z, axi.z*axi.x*ic + si*axi.y, axi.x*axi.y*ic + si*axi.z, axi.y*axi.y*ic + co, axi.z*axi.y*ic - si*axi.x, axi.x*axi.z*ic - si*axi.y, axi.y*axi.z*ic + si*axi.x, axi.z*axi.z*ic + co); 

जैसा कि आपने देखा होगा, हम वापसी मूल्य के कोसाइन की गणना करके इसे तुरंत रद्द करने के लिए एक गलत और महंगे एकोस कॉल कर रहे हैं। और पहला प्रश्न प्रकट होता है: "क्यों नहीं acos() ---> cos() कॉल चेन छोड़ें और CPU समय बचाएं?" इसके अलावा, क्या यह हमें यह नहीं बताता है कि हम कुछ गलत और बहुत जटिल कर रहे हैं, और यह कि कुछ सरल गणितीय सिद्धांत हमारे पास आते हैं जो इस अभिव्यक्ति के सरलीकरण के माध्यम से खुद को प्रकट करता है?

आप तर्क दे सकते हैं कि सरलीकरण नहीं किया जा सकता है, क्योंकि आपको साइन की गणना करने के लिए कोण की आवश्यकता होगी। हालाँकि, ऐसा नहीं है। यदि आप वैक्टर के वेक्टर उत्पाद से परिचित हैं, तो आप जानते हैं कि जैसे स्केलर उत्पाद में कोसाइन होता है, वैसे ही वेक्टर में साइन होता है। अधिकांश ग्राफिक प्रोग्रामर समझते हैं कि वैक्टर के एक स्केलर उत्पाद की आवश्यकता क्यों है, लेकिन हर कोई यह नहीं समझता है कि वेक्टर उत्पाद की आवश्यकता क्यों है (और इसका उपयोग केवल मानदंडों और रोटेशन अक्षों को पढ़ने के लिए किया जाता है)। मूल रूप से, गणितीय सिद्धांत जो हमें कॉस / एकोस जोड़ी से छुटकारा पाने में मदद करता है, हमें यह भी बताता है कि जहां एक अदिश उत्पाद है, वहां संभवतः एक वेक्टर उत्पाद है जो गुम जानकारी (लंबवत भाग, साइन) की सूचना देता है।

$$

$$|| \ vec {a} \ टाइम्स \ vec {b} || = ab \ sin {\ angle \ vec {a} \ vec {b}}$$

किसी स्थान या वस्तु को घुमाने का सही तरीका

अब हम बीच के कोण की साइन निकाल सकते हैं $$$\ vec {z}$और $$$\ vec {d}$बस उनके वेक्टर उत्पाद की लंबाई को देखकर ... - याद रखें $$$\ vec {z}$और $$$\ vec {d}$सामान्यीकृत! और इसका मतलब यह है कि हम (हम चाहिए !!) इस तरह से समारोह को फिर से लिखना चाहिए:

 const vec3 axi = cross( z, d ); const float si = length( axi ); const float co = dot( z, d ); const mat3x3 rot = rotationAxisCosSin( axi/si, co, si ); 

और सुनिश्चित करें कि हमारा नया रोटेशन मैट्रिक्स निर्माण कार्य, rotationAxisCosSin() , कहीं भी साइन और कॉशन की गणना नहीं करता है, लेकिन उन्हें तर्क के रूप में लेता है:

 mat3x3 rotationAxisCosSin( const vec3 & v, const float co, const float si ) { const float ic = 1.0f - co; return mat3x3( vx*vx*ic + co, vy*vx*ic - si*vz, vz*vx*ic + si*vy, vx*vy*ic + si*vz, vy*vy*ic + co, vz*vy*ic - si*vx, vx*vz*ic - si*vy, vy*vz*ic + si*vx, vz*vz*ic + co ); } 

एक और बात है जो सामान्यीकरण और वर्गमूल से छुटकारा पाने के लिए किया जा सकता है - एक नए फ़ंक्शन में पूरे तर्क को 1/si करना और मैट्रिक्स को 1/si पास करना:

 mat3x3 rotationAlign( const vec3 & d, const vec3 & z ) { const vec3 v = cross( z, d ); const float c = dot( z, d ); const float k = (1.0fc)/(1.0fc*c); return mat3x3( vx*vx*k + c, vy*vx*k - vz, vz*vx*k + vy, vx*vy*k + vz, vy*vy*k + c, vz*vy*k - vx, vx*vz*K - vy, vy*vz*k + vx, vz*vz*k + c ); } 

बाद में, ज़ोल्टन व्राणा ने देखा कि k को k = 1/(1+c) सरलीकृत किया जा सकता है, जो न केवल गणितीय रूप से अधिक सुरुचिपूर्ण दिखता है, बल्कि k और, के लिए दो सुविधाएँ चलती है, इस प्रकार, पूरे फ़ंक्शन ( $$$\ vec {d}$और $$$\ vec {z}$समांतर) एक में जाता है (जब $$$\ vec {d}$और $$$\ vec {z}$इस मामले में संयोग से कोई स्पष्ट रोटेशन नहीं है)। अंतिम कोड कुछ इस तरह दिखता है:

 mat3x3 rotationAlign( const vec3 & d, const vec3 & z ) { const vec3 v = cross( z, d ); const float c = dot( z, d ); const float k = 1.0f/(1.0f+c); return mat3x3( vx*vx*k + c, vy*vx*k - vz, vz*vx*k + vy, vx*vy*k + vz, vy*vy*k + c, vz*vy*k - vx, vx*vz*K - vy, vy*vz*k + vx, vz*vz*k + c ); } 

हमने न केवल तीन त्रिकोणमितीय कार्यों से छुटकारा पा लिया और बदसूरत क्लैंप (और सामान्यीकरण!) से छुटकारा पा लिया, बल्कि अपने 3 डी गणित को भी वैचारिक रूप से सरल बना दिया। कोई ट्रान्सेंडैंटल फ़ंक्शंस नहीं। वैक्टर अन्य वैक्टर को संशोधित करने वाले मैट्रीक बनाते हैं। और यह महत्वपूर्ण है, क्योंकि आपके 3 डी इंजन में कम त्रिकोणमिति, न केवल तेज और स्पष्ट हो जाती है, बल्कि, सबसे पहले, गणितीय रूप से अधिक सुरुचिपूर्ण (अधिक सही!)।