3 डी में आंखों के अनुकूलन को दोहराएं, या डमी के लिए एचडीआर

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



खेलों में, इस प्रभाव को अनुकरण करने के लिए टोनमैपिंग नामक एक तंत्र का उपयोग किया जाता है।

tonemapping - आंख / कैमरा / मॉनिटर ( LDR , कम गतिशील रेंज, दोनों पक्षों पर सीमित) की धारणा के अंतिम अंतराल पर चमक की पूरी अनंत श्रेणी ( HDR , उच्च गतिशील रेंज, 0 से अनंत तक) को पेश करने की प्रक्रिया।

एचडीआर के साथ काम करने के लिए, हमें एक उपयुक्त स्क्रीन बफर की आवश्यकता है जो एक से अधिक मूल्यों का समर्थन करता है। हमारा कार्य, हालांकि, इन मूल्यों को सीमा [0..1] में सही रूप से परिवर्तित करना होगा।



सबसे पहले, हमें किसी तरह दृश्य की समग्र चमक का पता लगाना चाहिए। ऐसा करने के लिए, आपको सभी पिक्सेल की ज्यामितीय औसत चमक की गणना करने की आवश्यकता है।

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

हम अपनी तस्वीर को दो की शक्ति के बराबर एक पक्ष के साथ निकटतम वर्ग में निचोड़ते हैं और इसे तिरस्कृत करते हैं। तब हम इसे हर बार दो बार संपीड़ित करेंगे, जब तक कि एक पिक्सेल शेष न हो:



तस्वीर को संपीड़ित करने के लिए, हम चार पड़ोसी पिक्सेल लेंगे और उनमें से मध्य का चयन करेंगे (हमारे मामले में, इसके बजाय अधिकतम एक)। ज्यामितीय माध्य की त्वरित गणना के लिए, हम सूत्र का उपयोग करते हैं

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

RenderTextureFormat rtFormat = RenderTextureFormat.ARGBFloat; if (lumBuffer == null) { lumBuffer = new RenderTexture (LuminanceGridSize, LuminanceGridSize, 0, rtFormat, RenderTextureReadWrite.Default); } RenderTexture currentTex = RenderTexture.GetTemporary (InitialSampling, InitialSampling, 0, rtFormat, RenderTextureReadWrite.Default); Graphics.Blit (source, currentTex, material, PASS_PREPARE); int currentSize = InitialSampling; while (currentSize > LuminanceGridSize) { RenderTexture next = RenderTexture.GetTemporary (currentSize / 2, currentSize / 2, 0, rtFormat, RenderTextureReadWrite.Default); Graphics.Blit (currentTex, next, material, PASS_DOWNSAMPLE); RenderTexture.ReleaseTemporary (currentTex); currentTex = next; currentSize /= 2; } 

 // Downsample pass Pass { CGPROGRAM #pragma vertex vert #pragma fragment fragDownsample float4 fragDownsample(v2f i) : COLOR { float4 v1 = tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * float2(-1,-1)); float4 v2 = tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * float2(1,1)); float4 v3 = tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * float2(-1,1)); float4 v4 = tex2D(_MainTex, i.uv + _MainTex_TexelSize.xy * float2(1,-1)); float mn = min(min(v1.x,v2.x), min(v3.x,v4.x)); float mx = max(max(v1.y,v2.y), max(v3.y,v4.y)); float avg = (v1.z+v2.z+v3.z+v4.z) / 4; return float4(mn, mx, avg, 1); } ENDCG } // Prepare pass Pass { CGPROGRAM #pragma vertex vert #pragma fragment fragPrepare float4 fragPrepare(v2f i) : COLOR { float v = tex2D(_MainTex, i.uv); float l = log(v + 0.001); return half4(l, l, l, 1); } ENDCG } 

ध्यान दें कि जब मूल छवि को लॉगरिडेट करते हैं, तो हम पूरी तरह से काले (0) पिक्सेल के मामले में ब्रह्मांड के पतन से बचने के लिए एक छोटा सा स्थिरांक जोड़ते हैं।

प्रत्येक कमी कदम पर, हमारी बनावट न्यूनतम (R), अधिकतम (G), और लघुगणक (B) चमक मान संग्रहीत करती है।

इसके बाद एक छोटी सी ट्रिक आती है जो आपको बनावट और "GPU" को पूरी तरह से "कस्टमाइज़" करने से बचने की अनुमति देगा: हम आकार में 1 पिक्सेल की एक निरंतर बनावट बनाएंगे और प्रत्येक फ्रेम पर हम एक छोटे से अल्फा (पारदर्शिता) के साथ एक नया चमक मान (1 पिक्सेल) लगाएंगे। इस प्रकार, संग्रहीत चमक मूल्य धीरे-धीरे वर्तमान में आ जाएगा, आवश्यकतानुसार।

 if (!lumBuffer.IsCreated ()) { Debug.Log ("Luminance map recreated"); lumBuffer.Create (); //     ,     Graphics.Blit (currentTex, lumBuffer); } else { material.SetFloat ("_Adaptation", AdaptationCoefficient); Graphics.Blit (currentTex, lumBuffer, material, PASS_UPDATE); } 

अनुकूलन क्षमता - 0.005 के क्रम का गुणांक, जो चमक के लिए अनुकूलन की गति निर्धारित करता है।

यह हमारे दो बनावट (मूल छवि और चमक) और पहले "एक्सपोजर" को दूसरे से मान का उपयोग करके ले जाता है।

 material.SetTexture ("_LumTex", lumBuffer); material.SetFloat ("_Key", Key); material.SetFloat ("_White", White); material.SetFloat ("_Limit", Limit); Graphics.Blit (source, destination, material, PASS_MAIN); 

 // Main pass Pass { CGPROGRAM #pragma vertex vert #pragma fragment frag float4 frag(v2f i) : COLOR { half4 cColor = tex2D(_MainTex, i.uv); float4 cLum = tex2D(_LumTex, i.uv); float lMin = exp(cLum.x); float lMax = exp(cLum.y); float lAvg = exp(cLum.z); lAvg = max(lMax / 2, _Limit); // force override for dark scene float lum = max(0.000001, Luminance(cColor.rgb)); float scaled = _Key / lAvg * lum; scaled *= (1 + scaled / _White / _White) / (1+scaled); return scaled * cColor; } ENDCG } 

यहां हम लघुगणक से चमक मूल्य को बहाल करते हैं, स्केल फैक्टर (स्केल) की गणना करते हैं, और सफेद स्तर (_White) के लिए एक सुधार करते हैं।

उपयोग किए गए पैरामीटर:

• कुंजी - दृश्य की समग्र चमक को समायोजित करती है, जिसे "सामान्य" माना जाता है
• सीमा - आंख की अधिकतम संवेदनशीलता को सीमित करता है, यह देखने की अनुमति नहीं देता है कि शिकारी कैसे है
• सफेद - रेंज की चौड़ाई को समायोजित करता है, यह दर्शाता है कि छवि में क्या चमक "सफेद" माना जाएगा

परिणाम:



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

रेइनहार्ड में दिनमान के बारे में अधिक पढ़ें
कोड
शेडर