विंडोज मोबाइल पर पिक्सेल प्रति एक गुणा में अल्फा-सम्मिश्रण

विंडोज मोबाइल पर ग्राफिक्स में शामिल लोगों ने शायद गैपीड्रॉव ग्राफिक्स लाइब्रेरी के बारे में सुना है। यदि आप उनकी विशेषता सूची को देखते हैं , तो उच्च प्रदर्शन अनुभाग में आप निम्नलिखित शब्द पा सकते हैं: "अस्पष्टता के साथ सतहों को खींचने के लिए प्रति पिक्सेल केवल एक गुणन की आवश्यकता होगी"। यही है, उनका दावा है कि पारभासी चित्रों को खींचने के लिए प्रति पिक्सेल केवल एक गुणन की आवश्यकता होती है।

इस लेख में मैं यह समझाने की कोशिश करूंगा कि यह कैसे संभव है।

सबसे पहले, विंडोज मोबाइल वाले अधिकांश उपकरणों में 65 हजार रंगों के साथ एक स्क्रीन है। यही है, स्क्रीन पर प्रत्येक पिक्सेल के लिए, 2 बाइट्स स्मृति में आवंटित किए जाते हैं। दूसरे, ऐसे उपकरणों में 32-बिट प्रोसेसर होता है। ऐसे प्रोसेसर पर, 2-बाइट संख्याओं के साथ गणितीय कार्य करने की गति 4-बाइट संख्याओं के साथ काम करने की गति से थोड़ी भिन्न होती है। यह वह जगह है जहाँ अनुकूलन गणनाओं में से एक निहित है। ग्राफिक्स लाइब्रेरी एक बार में 2 पिक्सल प्रोसेस करती है।

आइए देखें कि 16-बिट पिक्सेल कैसे काम करता है। ऊपरी 5 बिट्स लाल के लिए आरक्षित हैं, फिर हरे रंग के लिए 6 बिट और नीले रंग के लिए 5 बिट्स शेष हैं।

P = [RRRR RGGG GGGB BBBB] 15 8 7 0 

उसी समय, रंग स्वयं सूत्र के अनुसार पारियों और मुखौटे का उपयोग करके प्राप्त किया जा सकता है:

 int R = (P >> 11) & 0x1f; int G = (P >> 5) & 0x3f; int B = P & 0x1f; 

उलटा परिवर्तन द्वारा एक पिक्सेल प्राप्त किया जाता है:

 unsigned short P = (R << 11) + (G << 5) + B; 

जब हम पारदर्शिता के साथ दूसरे के ऊपर एक पिक्सेल खींचने की कोशिश करते हैं, तो रंग मिश्रण होता है। दोनों पिक्सेल 3 घटकों में विभाजित हैं: लाल, नीला, हरा। फिर घटक मिश्रण करते हैं, लाल के साथ लाल मिक्स, नीले के साथ नीले मिक्स, हरे के साथ हरे मिक्स। और प्राप्त मूल्यों से एक नया पिक्सेल संकलित किया जाता है।

सामान्य तौर पर, रंग मिश्रण इस तरह दिखता है:

 C = C1*α + C2*(1 - α) 

C1 पहले पिक्सेल से लाल, हरे या नीले रंग का मूल्य है।
C2 दूसरे पिक्सेल में एक ही रंग का मूल्य है।
सी परिणामी रंग है।
α - पारदर्शिता गुणांक, 0 से 1 तक मान लेता है।

यह α के वास्तविक मूल्य को संग्रहीत करने और इसके साथ संचालित करने के लिए काफी महंगा है, विशेष रूप से हाथ में कंप्यूटर पर, इसलिए यह कुछ पूर्णांक सीमा तक सीमित है। आमतौर पर, मान 0-255 का उपयोग किया जाता है, लेकिन 5-बिट α 5-बिट रंग के लिए पर्याप्त है।

सबसे पहले, ध्यान दें कि 50% पारदर्शिता के साथ रंग मिश्रण कैसे किया जाता है:

 C = C1/2 + C2/2 

2 से डिवीजन को एक शिफ्ट से बदला जा सकता है:

 C = (C1 >> 1) + (C2 >> 1) 

अब देखते हैं कि जब आप एक से दो पिक्सेल मिलाते हैं तो क्या होता है:

 P = (R1 >> 1 + R2 >> 1) << 11 + (G1 >> 1 + G2 >> 1) << 5 + (B1 >> 1 + B2 >> 1) 

हमें मिलने वाले कोष्ठकों का विस्तार करना:

 P = (P1 & 0xf7de) >> 1 + (P2 & 0xf7de) >> 1 

0xf7de का एक मुखौटा यह सुनिश्चित करने के लिए प्रकट होता है कि प्रत्येक रंग घटक में 1 द्वारा बदलाव सही है। की तुलना करें:

 [RRRR RGGG GGGB BBBB] = P [0RRR RRGG GGGG BBBB] = P >> 1 //         [RRRR RGGG GGGB BBBB] = P [1111 0111 1101 1110] = 0xf7de [RRRR 0GGG GG0B BBB0] = P & 0xf7de //      [0RRR R0GG GGG0 BBBB] = P & 0xf7de >> 1 

इस पद्धति के समान, आप पिक्सल 1 से 3, 1 से 7 तक मिश्रण के लिए एक ही ऑपरेशन कर सकते हैं ... लेकिन इन मामलों में यह विधि पूरी तरह से अप्रभावी है, मुख्य रूप से इस तथ्य के कारण कि विभाजन गुणन से पहले होता है। इसलिए, आपको पहले गुणा करने के लिए जगह बनाना चाहिए। ध्यान दें कि m-bit अहस्ताक्षरित संख्या को n-bit से गुणा करने पर, हमें एक संख्या प्राप्त होती है जो m + n बिट्स से अधिक नहीं होती है। यही है, आपको प्रत्येक रंग के सामने 5 बिट्स को मुक्त करने की आवश्यकता है, और इसके लिए आप पिक्सेल रंगों को समान और विषम में विभाजित कर सकते हैं और पहले से ही उन पर काम कर सकते हैं। इसलिए हम प्रति पिक्सेल 2 गुणन का उपयोग करते हुए अगली सम्मिश्रण प्रक्रिया में आए:

 #define Shift(p) ((p)>>5) #define OddCol(p) ((p) & 0x07E0F81F) #define EvenCol(p) ((p) & 0xF81F07E0) //      2  register unsigned int p1 = *dst; register unsigned int p2 = *(src++); //  4 ,    2   *(dst++) = OddCol( Shift(OddCol(p1)*a + OddCol(p2)*(32 - a)) ) | EvenCol( Shift(EvenCol(p1))*a + Shift(EvenCol(p2))*(32 - a) ); 

एक और गुणा से छुटकारा पाने के लिए कैसे? आइए कोष्ठक खोलने की कोशिश करें और शर्तों को फिर से व्यवस्थित करें:

 C = (C1*α + C2*(32 - α)) >> 5 = (C1 - C2)*α >> 5 + C2 

लेकिन कोष्ठकों में एक ऋणात्मक संख्या दिखाई दे सकती है, और अंकगणित संचालन नकारात्मक संख्याओं के साथ अतिप्रवाह पर आधारित होते हैं। इस प्रकार, कम्प्यूटेशन को समानांतर बनाने के लिए इस फॉर्मूले को लागू करना असंभव है। इसलिए, अधिकतम संभव जोड़कर नकारात्मक मूल्यों से छुटकारा पाएं:

 C = (C1 - C2 + 32 - 32)*α >> 5 + C2 = (C1 - C2 + 32)*α >> 5 + C2 - α 

इस सूत्र और सम विषम रंगों के साथ एक चाल का उपयोग करके, आप एक पिक्सेल मिश्रण प्रक्रिया प्राप्त कर सकते हैं जो प्रति पिक्सेल केवल एक गुणन का उपयोग करता है:

 #define OddCol(p) ((p) & 0x07E0F81F) #define EvenCol(p) ((p) & 0xF81F07E0) register unsigned int p1 = *dst; register unsigned int p2 = *(src++); register unsigned int oddA = (a<<22) | (a<<11) | (a); register unsigned int evenA = (a<<27) | (a<<16) | (a<<6); register unsigned int oddP2 = OddCol(p2); register unsigned int evenP2 = EvenCol(p2); // 2    2  oddCol = (((OddCol(p1) - oddP2 + 0x08010020) * a) >> 5) + oddP2 - oddA; evenCol = ((( (EvenCol(p1)>>5) - (evenP2>>5) + 0x08010040) * a) + evenP2 - evenA ); *(dst++) = OddCol(oddCol) | EvenCol(evenCol);