पेर्लिन की फजी दुनिया शोर की

पेरलिन शोर क्या है?

पेरलिन के शोर का आविष्कार 1983 में केन पेरलिन (जिन्होंने इस उपलब्धि के लिए अमेरिकन एकेडमी ऑफ मोशन पिक्चर आर्ट्स एंड साइंसेज से एक पुरस्कार प्राप्त किया था) द्वारा किया गया था। आप देखते हैं, उन दिनों हर कोई फोटोरिअलिज़्म के लिए प्रयास कर रहा था, लेकिन यह हमेशा कमी थी। केन पेर्लिन ने 3 डी मॉडलों के दयनीय "कंप्यूटर" उपस्थिति से छुटकारा पाने के लिए इस शोर एल्गोरिथ्म का आविष्कार किया। कंप्यूटर ग्राफिक्स में शोर एक यादृच्छिक संख्या जनरेटर है। यह एक यादृच्छिक, असंरचित पैटर्न है, और यह तब उपयोगी होता है जब आपको स्पष्ट संरचना ^{1 की} कमी वाले विस्तृत भागों के स्रोत की आवश्यकता होती है। पर्लिन शोर एक बहुआयामी एल्गोरिथ्म है जिसका उपयोग प्रक्रियात्मक पीढ़ी, बनावट, इलाके की पीढ़ी, मानचित्र पीढ़ी, सतह पीढ़ी, शीर्ष पीढ़ी, और इसी तरह आगे और आगे किया जाता है। नीचे दी गई तालिका में पर्लिन शोर की क्षमताओं की सीमा दर्शाई गई है:

आयामी स्वरूप	कच्चा शोर (ग्रेस्केल)	आवेदन
1		हाथ से खींची हुई वेक्टर वस्तुएं
2		प्रक्रियात्मक बनावट और ज्वाला जैसी वस्तुएं
3		माइनक्राफ्ट राहत में प्रयुक्त पेरलिन शोर

पेर्लिन ने शोर की निम्नलिखित परिभाषा दी: शोर श्वेत शोर का एक सन्निकटन है, जो एक सप्तक ³ की सीमा तक सीमित है। शोर की औपचारिक परिभाषा इस प्रकार है:

$$

$$f_N (y_1, y_2, \ cdots, y_n; x_1, x_2, \ cdots, x_n) = P (N (x_1), N (x_2), \ cdots, N (x_n))$$

जहाँ $$$एन (एक्स)$- शोर समारोह। पेरलिन का शोर प्रक्रियात्मक शोर है। "विशेषण प्रक्रियात्मक का उपयोग कंप्यूटर विज्ञान में डेटा संरचनाओं द्वारा वर्णित प्रोग्राम कोड द्वारा वर्णित संस्थाओं को अलग करने के लिए किया जाता है।" ⁴ यही है, कुछ उत्पन्न , और मुश्किल सेट नहीं है। इसके बजाय प्रक्रियात्मक शोर का उपयोग करना अच्छा है, उदाहरण के लिए, मैन्युअल रूप से शोर पैदा करना? प्रक्रियात्मक शोर कॉम्पैक्ट है , अर्थात् कम जगह लेता है। यह अवर्णनीय है , अर्थात अपामार्ग । यह पैरामीट्रिक है , इसे बेतरतीब ढंग से एक्सेस किया जा सकता है; उसके पास कई अन्य फायदे भी हैं जो कलाकार के जीवन को सरल बनाते हैं ... लेकिन क्या यह हमारा अंतिम लक्ष्य नहीं है - कलाकार की सेवा करना? कल मैंने आफ्टर इफेक्ट्स के लिए प्लग-इन बनाया, जो मेरी पिछली पोस्ट में देखा जा सकता है। मैंने उसमें कलाकार के हितों का ध्यान नहीं रखा, केवल मेरे अहंकार के हितों का, इसलिए किसी ने इसे डाउनलोड नहीं किया। मैंने सबक को समझा: कलाकार की सेवा करो, अपने आप से नहीं।

पेरलिन से पहले, झंझरी के ग्रेडिएंट का शोर दिखाई दिया। वे यादृच्छिक मूल्यों के बीच प्रक्षेप द्वारा उत्पन्न हुए थे, और पेरलिन शोर में, प्रत्येक क्यूटेक्स के लिए एक क्यूबिक जाली का उपयोग किया जाता है, और फिर स्पलाइन इंटरपोलेशन किया जाता है। "एक छद्म यादृच्छिक ढाल जाली बिंदु से हैशिंग द्वारा प्राप्त किया जाता है और ढाल का चयन करने के लिए परिणाम का उपयोग करता है।" ये हैश 12 वैक्टर में बदल जाते हैं और केंद्र से किनारों तक पांचवें डिग्री के बहुपद का उपयोग करके प्रक्षेपित होते हैं। यह कल्पना करना मुश्किल है, है ना? चिंता मत करो। मैं इसे चित्र ^{6 में} और छद्म कोड ⁷ में दिखाऊंगा।


"" पांचवीं डिग्री के बहुपद का उपयोग करके केंद्र से किनारों तक प्रक्षेपित किया जाता है "

और यहाँ हैश फ़ंक्शन के बिना क्लासिक पेर्लिन स्यूडोकोड है:

// Function to linearly interpolate between a0 and a1 // Weight w should be in the range [0.0, 1.0] float lerp(float a0, float a1, float w) { return (1.0 - w)*a0 + w*a1; // as an alternative, this slightly faster equivalent formula can be used: // return a0 + w*(a1 - a0); } // Computes the dot product of the distance and gradient vectors. float dotGridGradient(int ix, int iy, float x, float y) { // Precomputed (or otherwise) gradient vectors at each grid node extern float Gradient[IYMAX][IXMAX][2]; // Compute the distance vector float dx = x - (float)ix; float dy = y - (float)iy; // Compute the dot-product return (dx*Gradient[iy][ix][0] + dy*Gradient[iy][ix][1]); } // Compute Perlin noise at coordinates x, y float perlin(float x, float y) { // Determine grid cell coordinates int x0 = int(x); int x1 = x0 + 1; int y0 = int(y); int y1 = y0 + 1; // Determine interpolation weights // Could also use higher order polynomial/s-curve here float sx = x - (float)x0; float sy = y - (float)y0; // Interpolate between grid point gradients float n0, n1, ix0, ix1, value; n0 = dotGridGradient(x0, y0, x, y); n1 = dotGridGradient(x1, y0, x, y); ix0 = lerp(n0, n1, sx); n0 = dotGridGradient(x0, y1, x, y); n1 = dotGridGradient(x1, y1, x, y); ix1 = lerp(n0, n1, sx); value = lerp(ix0, ix1, sy); return value; } 

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

व्यवहार में परलिन शोर: जीएलएसएल कार्यान्वयन

तो, चलो GLSL पर पेरलिन के शोर के बारे में बात करते हैं। पर्लिन शोर का उपयोग तरंग के रूप में, फैलाने वाले रंग के रूप में, फैलाना सामग्री के रूप में, टिमटिमाते प्रकाश के रूप में, या बनावट पर धब्बे के रूप में किया जा सकता है। व्यक्तिगत रूप से, मैंने इसे रंग की झिलमिलाहट के रूप में इस उदाहरण में उपयोग किया।


जैसा कि मैंने इस लेख को लिखा है, मैं एक प्लग-इन के लिए बनाने के बारे में सोच रहा हूं After Effects जो कि पेरलिन शोर की कार्यक्षमता को जोड़ता है।

पेरलिन का सबसे सरल शोर ¹⁰ बनाया जा सकता है:

 float rand(vec2 c){ return fract(sin(dot(c.xy ,vec2(12.9898,78.233))) * 43758.5453); } float noise(vec2 p, float freq ){ float unit = screenWidth/freq; vec2 ij = floor(p/unit); vec2 xy = mod(p,unit)/unit; //xy = 3.*xy*xy-2.*xy*xy*xy; xy = .5*(1.-cos(PI*xy)); float a = rand((ij+vec2(0.,0.))); float b = rand((ij+vec2(1.,0.))); float c = rand((ij+vec2(0.,1.))); float d = rand((ij+vec2(1.,1.))); float x1 = mix(a, b, xy.x); float x2 = mix(c, d, xy.x); return mix(x1, x2, xy.y); } float pNoise(vec2 p, int res){ float persistance = .5; float n = 0.; float normK = 0.; float f = 4.; float amp = 1.; int iCount = 0; for (int i = 0; i<50; i++){ n+=amp*noise(p, f); f*=2.; normK+=amp; amp*=persistance; if (iCount == res) break; iCount++; } float nf = n/normK; return nf*nf*nf*nf; } 

 #define M_PI 3.14159265358979323846 float rand(vec2 co){return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);} float rand (vec2 co, float l) {return rand(vec2(rand(co), l));} float rand (vec2 co, float l, float t) {return rand(vec2(rand(co, l), t));} float perlin(vec2 p, float dim, float time) { vec2 pos = floor(p * dim); vec2 posx = pos + vec2(1.0, 0.0); vec2 posy = pos + vec2(0.0, 1.0); vec2 posxy = pos + vec2(1.0); float c = rand(pos, dim, time); float cx = rand(posx, dim, time); float cy = rand(posy, dim, time); float cxy = rand(posxy, dim, time); vec2 d = fract(p * dim); d = -0.5 * cos(d * M_PI) + 0.5; float ccx = mix(c, cx, dx); float cycxy = mix(cy, cxy, dx); float center = mix(ccx, cycxy, dy); return center * 2.0 - 1.0; } // p must be normalized! float perlin(vec2 p, float dim) { /*vec2 pos = floor(p * dim); vec2 posx = pos + vec2(1.0, 0.0); vec2 posy = pos + vec2(0.0, 1.0); vec2 posxy = pos + vec2(1.0); // For exclusively black/white noise /*float c = step(rand(pos, dim), 0.5); float cx = step(rand(posx, dim), 0.5); float cy = step(rand(posy, dim), 0.5); float cxy = step(rand(posxy, dim), 0.5);*/ /*float c = rand(pos, dim); float cx = rand(posx, dim); float cy = rand(posy, dim); float cxy = rand(posxy, dim); vec2 d = fract(p * dim); d = -0.5 * cos(d * M_PI) + 0.5; float ccx = mix(c, cx, dx); float cycxy = mix(cy, cxy, dx); float center = mix(ccx, cycxy, dy); return center * 2.0 - 1.0;*/ return perlin(p, dim, 0.0); } 

हालांकि, यह पेरलिन के शोर का एक नया संस्करण है, जिसे 2002 में बनाया गया था। यह देखने के लिए जाएं कि पेर्लिन का क्लासिक शोर कैसा है।

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


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

संदर्भ सामग्री

• प्रक्रियात्मक शोर कार्यों का एक सर्वेक्षण, कंप्यूटर ग्राफिक्स फोरम, वॉल्यूम 29 (2010), नंबर 8, पीपी 2379-2600
• कुशल कम्प्यूटेशनल शोर, जर्नल ऑफ़ ग्राफिक्स टूल्स वॉल्यूम 16, नहीं। 2: 85-94

1. ए सर्वे, एट अल
2. flafla2.imtqy.com/2014/08/09/perlinnoise.html
3. ए। लगुए एट अल
4. ए। लगै, एट अल
5. ए। लगै, एट अल
6. Flafla2.imtqy.com/2014/08/09/perlinnoise.html से
7. विकिपीडिया से
8. ए। लगै, एट अल
9. ए। लग्गे से अनुकूलित, एट अल
10. gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83