रैपिंग 2 डी पर्लिन शोर

Question

मैं ऊंचाई नक्शा पीढ़ी एल्गोरिदम के लिए पर्लिन शोर के साथ काम कर रहा हूं, मैं इसे किनारों के चारों ओर लपेटना चाहता हूं ताकि इसे निरंतर देखा जा सके .. क्या ऐसा करने का कोई आसान तरीका या चाल है ? मुझे लगता है मुझे एक गोलाकार शोर की तरह कुछ चाहिए ताकि क्षैतिज और लंबवत यह चारों ओर लपेट जाए। मैं सिर्फ 1 रैपिंग अक्ष के साथ भी खुश हूं लेकिन दो बेहतर होंगे।

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

अग्रिम धन्यवाद!

Answer 1

पर्लिन शोर तरंगों के योग के रूप में प्राप्त किया जाता है। तरंगों को यादृच्छिक मूल्यों को जोड़कर प्राप्त किया जाता है, और उच्च ऑक्टेटवे तरंगों में छोटे स्केलिंग कारक होते हैं जबकि इंटरप्लाटेड यादृच्छिक मूल्य एक-दूसरे के करीब होते हैं। इस लपेटने के लिए, आपको सामान्य टोरॉयडल फैशन में y- और x-axes के चारों ओर सही ढंग से इंटरपोलेट करने की आवश्यकता होती है, यानी यदि आपका एक्स-अक्ष x_min से x_max तक फैलता है, और बाएं सबसे यादृच्छिक बिंदु (जिसे इंटरपोलेट किया जा रहा है) है x0 पर और x1 पर सही (x_min < x0 < x1 < x_max), इंटरपोलेटेड पिक्सेल के लिए x1 से दाएं और x0 से छोड़ा गया मान x1 से x0 (किनारों के चारों ओर लपेटकर) से इंटरपोल करके प्राप्त किया जाता है।

यहां रैखिक इंटरपोलेशन का उपयोग करते हुए ऑक्टेट्स में से एक के लिए छद्म कोड। यह 256 x 256 मैट्रिक्स मानता है जहां पर्लिन शोर ग्रिड आकार दो पिक्सेल की शक्ति है ... बस इसे पठनीय बनाने के लिए। कल्पना कीजिए उदा। आकार == 16:

wrappable_perlin_octave(grid, size): 
    for (x=0;x<256;x+=size): 
    for (y=0;y<256;y+=size): 
     grid[x][y] = random() 
    for (x=0;x<256;x+=size): 
    for (y=0;y<256;y+=size): 
     if (x % size != 0 || y % size != 0): # interpolate 
     ax = x - x % size 
     bx = (ax + size) % 256 # wrap-around 
     ay = y - y % size 
     by = (ay + size) % 256 # wrap-around 
     h = (x % size)/size # horizontal balance, floating-point calculation 
     v = (y % size)/size # vertical balance, floating-point calculation 
     grid[x][y] = grid[ax][ay] * (1-h) * (1-v) + 
         grid[bx][ay] * h * (1-v) + 
         grid[ax][by] * (1-h) * v + 
         grid[bx][by] * h * v