💨 👍🏻 👼🏾 छद्म लेंस भड़कना 🎅🏻 🏁 👩‍🌾

नमस्कार, हेब्र! मैं आपको जॉन चैपमैन के लेख "छद्म लेंस भड़कना" का अनुवाद प्रस्तुत करता हूं।

लेंस फ्लेयर (लेंस फ्लेयर) एक लेंस सिस्टम में प्रकाश के प्रकीर्णन और अपवर्तन से उत्पन्न एक फोटोग्राफिक कलाकृति है। यद्यपि यह एक विरूपण साक्ष्य है, कंप्यूटर ग्राफिक्स में लेंस फ्लेयर का उपयोग करने के कई कारण हैं:

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

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

एल्गोरिथ्म

4 चरणों के होते हैं:

चढ़ाव / दहलीज।
लेंस भड़काने वाले तत्वों की उत्पत्ति ।
धुंधला।
मूल छवि के साथ अपस्केल / सम्मिश्रण।

1. चढ़ाव / थ्रेसहोल्ड

डाउनसमलिंग - बाद के चरणों की लागत को कम करने के लिए अनुकूलन। इसके अलावा, हम मूल छवि में सबसे चमकदार पिक्सल के सबसेट का चयन करना चाहते हैं। स्केल / पूर्वाग्रह (स्केल / पूर्वाग्रह) का उपयोग करके इसे प्राप्त करने के लिए एक लचीला तरीका प्रदान करता है:

uniform sampler2D uInputTex; uniform vec4 uScale; uniform vec4 uBias; noperspective in vec2 vTexcoord; out vec4 fResult; void main() { fResult = max(vec4(0.0), texture(uInputTex, vTexcoord) + uBias) * uScale; }

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

2. लेंस भड़काने वाले तत्वों की उत्पत्ति

लेंस भड़काने वाले तत्व छवि के केंद्र के बारे में घूमते हैं। इस प्रभाव का अनुकरण करके, हम पिछले चरण के परिणाम को क्षैतिज / लंबवत रूप से विस्तारित कर सकते हैं। तत्व निर्देशांक स्तर पर बनावट निर्देशांक का विस्तार करना आसान है:

 vec2 texcoord = -vTexcoords + vec2(1.0);

यह आवश्यक नहीं है; तत्व पीढ़ी इसके साथ और इसके बिना ही ठीक काम करती है। हालांकि, बनावट निर्देशांक बदलने के परिणामस्वरूप लेंस को मूल छवि से भड़कना प्रभाव को अलग करने में मदद मिलती है।

भूत

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

 uniform sampler2D uInputTex; uniform int uGhosts; // number of ghost samples uniform float uGhostDispersal; // dispersion factor noperspective in vec2 vTexcoord; out vec4 fResult; void main() { vec2 texcoord = -vTexcoord + vec2(1.0); vec2 texelSize = 1.0 / vec2(textureSize(uInputTex, 0)); // ghost vector to image centre: vec2 ghostVec = (vec2(0.5) - texcoord) * uGhostDispersal; // sample ghosts: vec4 result = vec4(0.0); for (int i = 0; i < uGhosts; ++i) { vec2 offset = fract(texcoord + ghostVec * float(i)); result += texture(uInputTex, offset); } fResult = result; }

ध्यान दें कि मैं फ्रैक्चर () का उपयोग यह सुनिश्चित करने के लिए करता हूं कि बनावट निर्देशांक चारों ओर लपेटता है; समान रूप से आप बनावट के लिए रैप मोड GL_REPEAT का उपयोग कर सकते हैं।

यहाँ परिणाम है:

आप भूत को उत्पन्न करने के लिए छवि के केंद्र के पास केवल उज्ज्वल क्षेत्रों की अनुमति देकर परिणाम में सुधार कर सकते हैं। हम नमूने के लिए केंद्र से घटने वाले वज़न को जोड़कर इसे प्राप्त कर सकते हैं:

 vec4 result = vec4(0.0); for (int i = 0; i < uGhosts; ++i) { vec2 offset = fract(texcoord + ghostVec * float(i)); float weight = length(vec2(0.5) - offset) / length(vec2(0.5)); weight = pow(1.0 - weight, 10.0); result += texture(uInputTex, offset) * weight; }

वजन फ़ंक्शन जितना संभव हो उतना सरल है - रैखिक। लूप के अंदर वजन की गणना करने का कारण यह है क्योंकि इनपुट छवि के केंद्र में उज्ज्वल क्षेत्र सीमाओं पर भूतों को "कास्ट" कर सकते हैं, लेकिन सीमाओं पर उज्ज्वल क्षेत्र भूतों को केंद्र में नहीं डाल सकते हैं।

अंतिम सुधार 1 डी बनावट के अनुसार, भूत के रेडियल रंग परिवर्तन है:

इसे भूत के अंतिम रंग को प्रभावित करने के लिए चक्र के बाद लगाया जाता है:

 result *= texture(uLensColor, length(vec2(0.5) - texcoord) / length(vec2(0.5)));

HALOS (हलो)

यदि हम वेक्टर को छवि के केंद्र में ले जाते हैं, जैसे कि भूत गणना में, लेकिन वेक्टर की लंबाई को ठीक करते हैं, तो हमें एक अलग प्रभाव मिलता है: मूल छवि को रेडियल रूप से विकृत किया जाता है:

हम एक नमूना द्वारा वजन को गुणा करके "हेलो" बनाने के लिए इसका उपयोग कर सकते हैं, जिससे विकृत छवि के योगदान को एक अंगूठी तक सीमित किया जा सकता है जिसका त्रिज्या uHaloWidth द्वारा नियंत्रित किया जाता है :

 // sample halo: vec2 haloVec = normalize(ghostVec) * uHaloWidth; float weight = length(vec2(0.5) - fract(texcoord + haloVec)) / length(vec2(0.5)); weight = pow(1.0 - weight, 5.0); result += texture(uInputTex, texcoord + haloVec) * weight;

CHROMATIC DISTORTION (रंग विकृति)

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

 vec3 textureDistorted( in sampler2D tex, in vec2 texcoord, in vec2 direction, // direction of distortion in vec3 distortion // per-channel distortion factor ) { return vec3( texture(tex, texcoord + direction * distortion.r).r, texture(tex, texcoord + direction * distortion.g).g, texture(tex, texcoord + direction * distortion.b).b ); }

इसे पिछली लिस्टिंग में टेक्सचर () कॉलिंग टेक्सचर के लिए डायरेक्ट रिप्लेसमेंट के रूप में इस्तेमाल किया जा सकता है। मैं निम्नानुसार दिशा और विकृति की गणना करता हूं:

 vec2 texelSize = 1.0 / vec2(textureSize(uInputTex, 0)); vec3 distortion = vec3(-texelSize.x * uDistortion, 0.0, texelSize.x * uDistortion); vec3 direction = normalize(ghostVec);

यद्यपि यह भ्रूण का कार्य सरल है, इसकी बनावट से x3 नमूने खर्च होते हैं, हालांकि ये सभी कैश-फ्रेंडली होने चाहिए, जब तक कि आप कुछ विशाल मूल्य पर uDistortion सेट न करें।

तत्वों की पीढ़ी के साथ, सब कुछ। यहाँ परिणाम है:

3. धब्बा

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

मैं नहीं बताऊंगा कि धब्बा कैसे बनाया जाता है; आप इसके बारे में विभिन्न इंटरनेट संसाधनों (गॉसियन कलंक) पर पढ़ सकते हैं।

4. मूल छवि के साथ अपस्केल / मिश्रण

तो, हम हमारे लेंस भड़क तत्वों, अच्छी तरह से धुंधला है। हम उन्हें मूल स्रोत छवि के साथ कैसे जोड़ सकते हैं? संपूर्ण रेंडर पाइपलाइन के संबंध में कई महत्वपूर्ण विचार हैं:

लेंस के भड़कने के साथ संयोजन करने से पहले किसी भी बाद के गति धुंधला या क्षेत्र की गहराई को लागू किया जाना चाहिए, इसलिए लेंस भड़काने वाले तत्व इन प्रभावों में भाग नहीं लेंगे।
किसी भी टोनहीपिंग से पहले लेंस भड़कना चाहिए। यह भौतिक समझ में आता है, क्योंकि आने वाली रोशनी में फिल्म / CMOS प्रतिक्रिया की नकल करता है, जिसमें से लेंस भड़कना एक अभिन्न अंग है।

इस बात को ध्यान में रखते हुए, परिणाम सुधारने के लिए हम इस स्तर पर कुछ कर सकते हैं:

लेंस DIRT

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

 uniform sampler2D uInputTex; // source image uniform sampler2D uLensFlareTex; // input from the blur stage uniform sampler2D uLensDirtTex; // full resolution dirt texture noperspective in vec2 vTexcoord; out vec4 fResult; void main() { vec4 lensMod = texture(uLensDirtTex, vTexcoord); vec4 lensFlare = texture(uLensFlareTex, vTexcoord) * lensMod; fResult = texture(uInputTex, vTexcoord) + lensflare; }

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

DIFFRACTION STARBURST

एक अतिरिक्त सुधार के रूप में, हम इसे लेंस की गंदगी में जोड़कर स्टारबर्स्ट बनावट का उपयोग कर सकते हैं:

बनावट के रूप में, स्टारबर्स्ट बहुत अच्छे नहीं लगते हैं। फिर भी, हम परिवर्तन करने वाले मैट्रिक्स को shader में पारित कर सकते हैं, जो हमें हर फ्रेम को घुमाने / विकृत करने और वांछित गतिशील प्रभाव प्राप्त करने की अनुमति देगा:

 uniform sampler2D uInputTex; // source image uniform sampler2D uLensFlareTex; // input from the blur stage uniform sampler2D uLensDirtTex; // full resolution dirt texture uniform sampler2D uLensStarTex; // diffraction starburst texture uniform mat3 uLensStarMatrix; // transforms texcoords noperspective in vec2 vTexcoord; out vec4 fResult; void main() { vec4 lensMod = texture(uLensDirtTex, vTexcoord); vec2 lensStarTexcoord = (uLensStarMatrix * vec3(vTexcoord, 1.0)).xy; lensMod += texture(uLensStarTex, lensStarTexcoord); vec4 lensFlare = texture(uLensFlareTex, vTexcoord) * lensMod; fResult = texture(uInputTex, vTexcoord) + lensflare; }

ULensStarMatrix परिवर्तन मैट्रिक्स कैमरा अभिविन्यास से प्राप्त मूल्य पर निम्नानुसार आधारित है:

 vec3 camx = cam.getViewMatrix().col(0); // camera x (left) vector vec3 camz = cam.getViewMatrix().col(1); // camera z (forward) vector float camrot = dot(camx, vec3(0,0,1)) + dot(camz, vec3(0,1,0));

केमरो मूल्य प्राप्त करने के अन्य तरीके हैं; सबसे महत्वपूर्ण बात यह है कि कैमरे को घुमाए जाने पर इसे लगातार बदलना चाहिए। मैट्रिक्स का निर्माण इस प्रकार है:

 mat3 scaleBias1 = ( 2.0f, 0.0f, -1.0f, 0.0f, 2.0f, -1.0f, 0.0f, 0.0f, 1.0f, ); mat3 rotation = ( cos(camrot), -sin(camrot), 0.0f, sin(camrot), cos(camrot), 0.0f, 0.0f, 0.0f, 1.0f ); mat3 scaleBias2 = ( 0.5f, 0.0f, 0.5f, 0.0f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, ); mat3 uLensStarMatrix = scaleBias2 * rotation * scaleBias1;

स्केल और पूर्वाग्रह मेट्रिसेस को बनावट उत्पत्ति की आवश्यकता है ताकि हम छवि के केंद्र के सापेक्ष स्टारबर्स्ट को घुमा सकें।

निष्कर्ष

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

युपीडी

लेखक ने मामूली अनुकूलन के साथ एक लेख भी प्रकाशित किया।
स्रोत कोड को यहां और यहां देखा जा सकता है ।

छद्म लेंस भड़कना