ओपनजीएल जानें। पाठ 5.8 - ब्लूम

फूल

पारंपरिक मॉनिटर के लिए उपलब्ध सीमित चमक रेंज के कारण, उज्ज्वल प्रकाश स्रोतों और चमकीले रोशनी वाले सतहों को स्पष्ट रूप से प्रदर्शित करने का कार्य परिभाषा के द्वारा मुश्किल है। मॉनिटर पर उज्ज्वल क्षेत्रों को उजागर करने के लिए सामान्य तरीकों में से एक ऐसी तकनीक है जो उज्ज्वल वस्तुओं के चारों ओर चमक का एक प्रभामंडल जोड़ती है, जो प्रकाश स्रोत के बाहर प्रकाश के "प्रसार" की धारणा देती है। नतीजतन, प्रेक्षक ऐसे प्रबुद्ध क्षेत्रों या प्रकाश स्रोतों की एक उच्च चमक की छाप देता है।

एक प्रभामंडल के वर्णित प्रभाव और स्रोत से परे प्रकाश के बाहर निकलने से एक बाद की प्रसंस्करण तकनीक प्राप्त होती है जिसे ब्लूम कहा जाता है । प्रभाव को लागू करने से प्रदर्शित दृश्य के सभी उज्ज्वल क्षेत्रों में चमक की एक विशेषता प्रभामंडल जुड़ जाता है, जिसे नीचे दिए गए उदाहरण में देखा जा सकता है:



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

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

खिल को लागू करने के लिए, प्रबुद्ध दृश्य को पहले सामान्य तरीके से प्रस्तुत किया जाता है। अगला, एक एचडीआर रंग बफर और एक रंगीन बफर जिसमें दृश्य के केवल उज्ज्वल हिस्से होते हैं, निकाले जाते हैं। इस निकाले गए चमकीले हिस्से की छवि फिर धुंधला हो जाती है और दृश्य के मूल एचडीआर छवि के शीर्ष पर मढ़ा जाता है।

इसे स्पष्ट करने के लिए, हम चरण दर चरण प्रक्रिया का विश्लेषण करेंगे। 4 चमकीले प्रकाश स्रोतों वाले एक दृश्य को रंगीन क्यूब्स के रूप में प्रदर्शित करें। इन सभी की चमक मान 1.5 से 15.0 तक है। यदि रंग बफर एचडीआर के लिए आउटपुट है, तो परिणाम निम्नानुसार है:


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


इसके अलावा, उज्ज्वल क्षेत्रों की यह छवि धुंधली है। प्रभाव की गंभीरता अनिवार्य रूप से लागू धब्बा फिल्टर की शक्ति और त्रिज्या से निर्धारित होती है:


उज्ज्वल क्षेत्रों की परिणामी धुंधली छवि उज्ज्वल वस्तुओं के चारों ओर हलो के अंतिम प्रभाव का आधार है। यह बनावट बस दृश्य की मूल HDR छवि के साथ मिश्रित है। चूंकि उज्ज्वल क्षेत्र धुंधले थे, इसलिए उनके आकार में वृद्धि हुई, जो अंततः प्रकाशता का एक दृश्य प्रभाव देता है जो प्रकाश स्रोतों की सीमाओं से परे जाता है:


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

तो, उपरोक्त क्रियाएं हमें खिल प्रभाव के लिए पोस्ट-प्रोसेसिंग प्रभाव का एक चरण-दर-चरण एल्गोरिथम देती हैं। नीचे दी गई छवि आवश्यक क्रियाओं को सारांशित करती है:


सबसे पहले, हमें किसी दिए गए सीमा मूल्य के आधार पर दृश्य के उज्ज्वल भागों के बारे में जानकारी चाहिए। यही हम करेंगे।

हाइलाइट निकालें

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

layout (location = 0) out vec4 FragColor; layout (location = 1) out vec4 BrightColor; 

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

 //       unsigned int hdrFBO; glGenFramebuffers(1, &hdrFBO); glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO); unsigned int colorBuffers[2]; glGenTextures(2, colorBuffers); for (unsigned int i = 0; i < 2; i++) { glBindTexture(GL_TEXTURE_2D, colorBuffers[i]); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //     glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, colorBuffers[i], 0 ); } 

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

 unsigned int attachments[2] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 }; glDrawBuffers(2, attachments); 

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

 #version 330 core layout (location = 0) out vec4 FragColor; layout (location = 1) out vec4 BrightColor; [...] void main() { [...] //      FragColor = vec4(lighting, 1.0); //         //   -    ,    float brightness = dot(FragColor.rgb, vec3(0.2126, 0.7152, 0.0722)); if(brightness > 1.0) BrightColor = vec4(FragColor.rgb, 1.0); else BrightColor = vec4(0.0, 0.0, 0.0, 1.0); } 

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

एल्गोरिथ्म का पता लगाने के बाद, हम समझ सकते हैं कि यह तकनीक एचडीआर प्रतिपादन के साथ इतनी अच्छी तरह से क्यों काम करती है। एचडीआर प्रारूप में प्रतिपादन रंग घटकों को 1.0 की ऊपरी सीमा से परे जाने की अनुमति देता है, जो आपको मानक अंतराल [0., 1.] के बाहर चमक दहलीज को अधिक लचीले ढंग से समायोजित करने की अनुमति देता है, जिससे फाइन-ट्यून की क्षमता प्रदान की जाती है जो दृश्य के वर्गों को उज्ज्वल बनाते हैं। एचडीआर का उपयोग किए बिना, आपको अंतराल [0., 1.] में एक चमक दहलीज के साथ संतोष करना होगा, जो काफी स्वीकार्य है, लेकिन चमक में एक और अधिक "तेज" कटऑफ की ओर जाता है, जो अक्सर खिलने को भी बहुत ही डरावना और आकर्षक बनाता है (पहाड़ों में अपने आप को एक बर्फ क्षेत्र में उच्च कल्पना करें) ।

शेडर निष्पादित होने के बाद, दो लक्ष्य बफ़र्स में दृश्य की एक सामान्य छवि होगी, साथ ही केवल उज्ज्वल क्षेत्रों वाली छवि होगी।


उज्ज्वल क्षेत्रों की छवि को अब धब्बा का उपयोग करके संसाधित किया जाना चाहिए। आप इसे एक साधारण आयताकार ( बॉक्स ) फ़िल्टर के साथ पूरा कर सकते हैं, जिसका उपयोग फ्रेम बफर सबक के पोस्टप्रोसेसिंग अनुभाग में किया गया था। लेकिन गाऊस फ़िल्टरिंग द्वारा बहुत बेहतर परिणाम प्राप्त होता है।

गौसियन ब्लर

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


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

फ़िल्टर के कार्यान्वयन के लिए भारांक गुणांक के दो-आयामी सरणी की आवश्यकता होगी, जिसे गौसियन वक्र का वर्णन करने वाले दो-आयामी अभिव्यक्ति के आधार पर भरा जा सकता है। हालांकि, हम तुरंत एक प्रदर्शन समस्या का सामना करेंगे: यहां तक ​​कि एक 32x32 टुकड़े में एक अपेक्षाकृत छोटे धब्बा कोर को संसाधित छवि के प्रत्येक टुकड़े के लिए 1024 बनावट के नमूनों की आवश्यकता होगी!

सौभाग्य से, हमारे लिए गॉसियन वक्र की अभिव्यक्ति में एक बहुत ही सुविधाजनक गणितीय विशेषता - पृथक्करण है, जो क्षैतिज और ऊर्ध्वाधर घटकों का वर्णन करने वाले एक दो आयामी अभिव्यक्ति से दो एक आयामी अभिव्यक्ति करना संभव बना देगा। यह दो दृष्टिकोणों में बदले में धुंधला होने की अनुमति देगा: क्षैतिज रूप से, और फिर प्रत्येक दिशाओं के अनुरूप वजन के सेट के साथ लंबवत। परिणामी छवि दो-आयामी एल्गोरिदम को संसाधित करते समय समान होगी, लेकिन इसके लिए वीडियो प्रोसेसर की बहुत कम प्रसंस्करण शक्ति की आवश्यकता होगी: बनावट से 1024 नमूनों के बजाय, हमें केवल 32 + 32 = 64 की आवश्यकता है! यह दो-पास गौसियन निस्पंदन का सार है।


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

फ़्रेम बफ़र ट्यूनिंग कोड पर जाने से पहले, आइए एक नज़र डालते हैं गॉसियन ब्लर शेडर कोड पर:

 #version 330 core out vec4 FragColor; in vec2 TexCoords; uniform sampler2D image; uniform bool horizontal; uniform float weight[5] = float[] (0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216); void main() { //     vec2 tex_offset = 1.0 / textureSize(image, 0); //    vec3 result = texture(image, TexCoords).rgb * weight[0]; if(horizontal) { for(int i = 1; i < 5; ++i) { result += texture(image, TexCoords + vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; result += texture(image, TexCoords - vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; } } else { for(int i = 1; i < 5; ++i) { result += texture(image, TexCoords + vec2(0.0, tex_offset.y * i)).rgb * weight[i]; result += texture(image, TexCoords - vec2(0.0, tex_offset.y * i)).rgb * weight[i]; } } FragColor = vec4(result, 1.0); } 

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

बनावट के आधार पर एक रंग बफर वाले दो फ्रेम बफ़र्स बनाएँ:

 unsigned int pingpongFBO[2]; unsigned int pingpongBuffer[2]; glGenFramebuffers(2, pingpongFBO); glGenTextures(2, pingpongBuffer); for (unsigned int i = 0; i < 2; i++) { glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[i]); glBindTexture(GL_TEXTURE_2D, pingpongBuffer[i]); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGB, GL_FLOAT, NULL ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, pingpongBuffer[i], 0 ); } 

जब हम दृश्य की एचडीआर बनावट प्राप्त करते हैं और उज्ज्वल क्षेत्रों की बनावट को निकालते हैं, तो हम तैयार किए गए फ्रेमबफर्स ​​की जोड़ी में से एक के रंगीन बफर को चमक बनावट के साथ भरते हैं और पिंग-पोंग प्रक्रिया को दस बार (पांच बार लंबवत, पांच क्षैतिज रूप से) शुरू करते हैं:

 bool horizontal = true, first_iteration = true; int amount = 10; shaderBlur.use(); for (unsigned int i = 0; i < amount; i++) { glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[horizontal]); shaderBlur.setInt("horizontal", horizontal); glBindTexture( GL_TEXTURE_2D, first_iteration ? colorBuffers[1] : pingpongBuffers[!horizontal] ); RenderQuad(); horizontal = !horizontal; if (first_iteration) first_iteration = false; } glBindFramebuffer(GL_FRAMEBUFFER, 0); 

प्रत्येक पुनरावृत्ति पर, हम फ़्रेम बफ़र्स में से एक का चयन करते हैं और लंगर डालते हैं कि क्या यह चलना क्षैतिज या लंबवत रूप से धुंधला हो जाएगा, और अन्य फ़्रेमबफ़र का रंग बफर तब धब्बा shader के लिए इनपुट बनावट के रूप में उपयोग किया जाता है। पहली पुनरावृत्ति पर, हमें स्पष्ट रूप से उज्ज्वल क्षेत्रों (ब्राइट टेक्सचर ) वाली छवि का उपयोग करना होगा - अन्यथा दोनों पिंग-पोंग फ्रेमबफ़र खाली रहेंगे। दस पास होने के बाद, मूल छवि एक पूर्ण गाऊसी फिल्टर द्वारा पांच बार धुंधली का रूप लेती है। उपयोग किया गया दृष्टिकोण हमें आसानी से धब्बा की डिग्री को बदलने की अनुमति देता है: अधिक पिंग-पोंग पुनरावृत्तियों, धब्बा जितना मजबूत।

हमारे मामले में, धुंधला परिणाम कुछ इस तरह दिखता है:


प्रभाव को पूरा करने के लिए, यह केवल धुंधली छवि को दृश्य के मूल एचडीआर छवि के साथ संयोजित करने के लिए बनी हुई है।

बनावट सम्मिश्रण

हाथ से प्रस्तुत किए गए दृश्य की एचडीआर बनावट और अति-निष्पादित क्षेत्रों की धुंधली बनावट होने के बाद, आपको इन दोनों छवियों को संयोजित करने के लिए प्रसिद्ध खिल प्रभाव या चमक का एहसास करना होगा। अंतिम टुकड़ा shader ( HDR प्रारूप के बारे में पाठ में प्रस्तुत एक के समान) बस यही करता है - यह दो बनावटों को मिलाता है:

 #version 330 core out vec4 FragColor; in vec2 TexCoords; uniform sampler2D scene; uniform sampler2D bloomBlur; uniform float exposure; void main() { const float gamma = 2.2; vec3 hdrColor = texture(scene, TexCoords).rgb; vec3 bloomColor = texture(bloomBlur, TexCoords).rgb; hdrColor += bloomColor; // additive blending //   vec3 result = vec3(1.0) - exp(-hdrColor * exposure); //     - result = pow(result, vec3(1.0 / gamma)); FragColor = vec4(result, 1.0); } 

क्या देखें: टोनिंग मैपिंग लगाने से पहले मिक्सिंग की जाती है। यह LDR ( लो डायनेमिक रेंज ) रेंज में प्रभाव से अतिरिक्त चमक को सही ढंग से अनुवाद करेगा, जबकि दृश्य में सापेक्ष चमक वितरण को बनाए रखेगा।

प्रसंस्करण के परिणाम - सभी उज्ज्वल क्षेत्रों को एक उल्लेखनीय चमक प्रभाव प्राप्त हुआ:


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

उदाहरण के लिए स्रोत कोड यहाँ है ।

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

अतिरिक्त संसाधन

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