คุณสร้างเสียงเพอร์ลินแบบเรียงต่อกันได้อย่างไร

ที่เกี่ยวข้อง:

• การสร้างเสียงรบกวนง่าย
• การทำความเข้าใจเสียงเพอร์ลิน

ฉันต้องการสร้างเสียงเพอร์ลินแบบเรียงต่อกันได้ ฉันทำงานจากฟังก์ชั่นของ Paul Bourke PerlinNoise*()ซึ่งเป็นแบบนี้:

// alpha is the "division factor" (how much to damp subsequent octaves with (usually 2))
// beta is the factor that multiplies your "jump" into the noise (usually 2)
// n is the number of "octaves" to add in
double PerlinNoise2D(double x,double y,double alpha,double beta,int n)
{
   int i;
   double val,sum = 0;
   double p[2],scale = 1;

   p[0] = x;
   p[1] = y;
   for (i=0;i<n;i++) {
      val = noise2(p);
      sum += val / scale;
      scale *= alpha;
      p[0] *= beta;
      p[1] *= beta;
   }
   return(sum);
}

ใช้รหัสเช่น:

real val = PerlinNoise2D( x,y, 2, 2, 12 ) ; // test

return val*val*skyColor + 2*val*(1-val)*gray + (1-val)*(1-val)*cloudColor ;

ให้ท้องฟ้าเหมือน

ซึ่งไม่สามารถเรียงต่อกันได้

ค่าพิกเซลคือ 0-> 256 (ความกว้างและความสูง) และพิกเซล (0,0) ใช้ (x, y) = (0,0) และพิกเซล (256,256) ใช้ (x, y) = (1,1)

ฉันจะทำให้เป็นไทล์ได้อย่างไร

มีสองส่วนในการสร้างเสียง fBm ที่เรียงต่อกันได้อย่างไร้รอยต่อเช่นนี้ ก่อนอื่นคุณต้องทำให้ฟังก์ชั่นเสียง Perlin เป็นแบบเรียงต่อกันได้ นี่คือบางส่วนของรหัส Python สำหรับฟังก์ชั่นลดเสียงรบกวน Perlin ที่ใช้งานได้กับทุกช่วงเวลาสูงสุด 256 (คุณสามารถขยายได้มากเท่าที่คุณต้องการโดยการแก้ไขส่วนแรก):

import random
import math
from PIL import Image

perm = range(256)
random.shuffle(perm)
perm += perm
dirs = [(math.cos(a * 2.0 * math.pi / 256),
         math.sin(a * 2.0 * math.pi / 256))
         for a in range(256)]

def noise(x, y, per):
    def surflet(gridX, gridY):
        distX, distY = abs(x-gridX), abs(y-gridY)
        polyX = 1 - 6*distX**5 + 15*distX**4 - 10*distX**3
        polyY = 1 - 6*distY**5 + 15*distY**4 - 10*distY**3
        hashed = perm[perm[int(gridX)%per] + int(gridY)%per]
        grad = (x-gridX)*dirs[hashed][0] + (y-gridY)*dirs[hashed][1]
        return polyX * polyY * grad
    intX, intY = int(x), int(y)
    return (surflet(intX+0, intY+0) + surflet(intX+1, intY+0) +
            surflet(intX+0, intY+1) + surflet(intX+1, intY+1))

เสียงเพอร์ลินนั้นเกิดจากการรวมกันของ "surflets" เล็ก ๆ น้อย ๆ ซึ่งเป็นผลมาจากการไล่ระดับสีแบบสุ่มและฟังก์ชั่น falloff แบบแยกส่วนได้ สิ่งนี้ให้พื้นที่เป็นบวก (สีเหลือง) และพื้นที่ลบ (สีน้ำเงิน)

กระดานโต้คลื่นมีขนาดเท่า 2x2 และอยู่กึ่งกลางของจุดขัดแตะจำนวนเต็มดังนั้นค่าของเสียงเพอร์ลินในแต่ละจุดในอวกาศจึงเกิดจากการรวมกระดานโต้คลื่นที่มุมเซลล์ที่มันครอบครอง

หากคุณกำหนดทิศทางการไล่ระดับสีในบางช่วงเวลาเสียงจะดังขึ้นเองในช่วงเวลาเดียวกัน นี่คือเหตุผลที่รหัสข้างต้นใช้เวลาโมดูโลประสานงานระยะเวลาก่อนที่จะ hashing มันผ่านตารางการเปลี่ยนแปลง

ขั้นตอนอื่นคือเมื่อรวมผลอ็อกเทฟคุณจะต้องการปรับช่วงเวลาด้วยความถี่ของอ็อกเทฟ โดยพื้นฐานแล้วคุณจะต้องการให้แต่ละอ็อกเทฟแต่ละภาพเรียงภาพทั้งหมดเพียงครั้งเดียวแทนที่จะเป็นหลาย ๆ ครั้ง:

def fBm(x, y, per, octs):
    val = 0
    for o in range(octs):
        val += 0.5**o * noise(x*2**o, y*2**o, per*2**o)
    return val

นำมารวมกันและคุณจะได้รับสิ่งนี้:

size, freq, octs, data = 128, 1/32.0, 5, []
for y in range(size):
    for x in range(size):
        data.append(fBm(x*freq, y*freq, int(size*freq), octs))
im = Image.new("L", (size, size))
im.putdata(data, 128, 128)
im.save("noise.png")

อย่างที่คุณเห็นนี่มันจะเรียงต่อกันอย่างแท้จริง:

ด้วยการปรับแต่งขนาดเล็กและการทำแผนที่สีนี่คือภาพเมฆที่เรียงต่อกัน 2x2:

หวังว่านี่จะช่วยได้!

นี่เป็นวิธีที่ค่อนข้างฉลาดที่ใช้เสียง 4D Perlin

โดยทั่วไปแผนที่พิกัด X ของพิกเซลของคุณไปยังวงกลม 2D และพิกัด Y ของพิกเซลของคุณไปยังวงกลม 2D ที่สองและวางทั้งสองวงกลมมุมฉากซึ่งกันและกันในพื้นที่ 4D พื้นผิวที่เกิดขึ้นนั้นสามารถเรียงต่อกันได้ไม่มีการบิดเบือนที่ชัดเจนและไม่ทำซ้ำในลักษณะที่พื้นผิวที่ทำมิเรอร์

รหัสการคัดลอกวางจากบทความ:

for x=0,bufferwidth-1,1 do
    for y=0,bufferheight-1,1 do
        local s=x/bufferwidth
        local t=y/bufferheight
        local dx=x2-x1
        local dy=y2-y1

        local nx=x1+cos(s*2*pi)*dx/(2*pi)
        local ny=y1+cos(t*2*pi)*dy/(2*pi)
        local nz=x1+sin(s*2*pi)*dx/(2*pi)
        local nw=y1+sin(t*2*pi)*dy/(2*pi)

        buffer:set(x,y,Noise4D(nx,ny,nz,nw))
    end
end

โอเคเข้าใจแล้ว. คำตอบคือเดินในพรูในเสียง 3 มิติสร้างพื้นผิว 2D จากมัน

รหัส:

Color Sky( double x, double y, double z )
{
  // Calling PerlinNoise3( x,y,z ),
  // x, y, z _Must be_ between 0 and 1
  // for this to tile correctly
  double c=4, a=1; // torus parameters (controlling size)
  double xt = (c+a*cos(2*PI*y))*cos(2*PI*x);
  double yt = (c+a*cos(2*PI*y))*sin(2*PI*x);
  double zt = a*sin(2*PI*y);
  double val = PerlinNoise3D( xt,yt,zt, 1.5, 2, 12 ) ; // torus

  return val*val*cloudWhite + 2*val*(1-val)*gray + (1-val)*(1-val)*skyBlue ;
}

ผล:

เมื่อ:

และปูกระเบื้อง:

วิธีง่าย ๆ อย่างหนึ่งที่ฉันสามารถนึกได้ก็คือการเอาท์พุทของฟังก์ชั่นรบกวนและกระจก / พลิกให้เป็นภาพที่มีขนาดใหญ่เป็นสองเท่า เป็นการยากที่จะอธิบายดังนั้นนี่คือภาพ:

ในกรณีนี้มันค่อนข้างชัดเจนว่าคุณทำอะไรเมื่อดูที่นี้ ฉันคิดได้สองวิธีในการ (อาจ :-)) แก้ไขสิ่งนี้:

1. คุณสามารถถ่ายภาพที่มีขนาดใหญ่ขึ้นจากนั้นก็จะสร้างจุดรบกวนบนด้านบนได้ แต่ (และฉันไม่แน่ใจว่าเป็นไปได้หรือไม่) มุ่งเน้นไปที่ตรงกลาง (เพื่อให้ขอบคงเดิม) มันสามารถเพิ่มความแตกต่างเล็กน้อยที่จะทำให้สมองของคุณคิดว่าไม่ใช่แค่ภาพสะท้อน

2. (ฉันยังไม่แน่ใจว่าเป็นไปได้หรือไม่) คุณสามารถลองเล่นซอกับอินพุตของฟังก์ชั่นลดจุดรบกวนเพื่อสร้างภาพเริ่มต้นที่แตกต่างกัน คุณต้องทำสิ่งนี้ด้วยการลองผิดลองถูก แต่มองหาฟีเจอร์ที่ดึงดูดสายตาคุณเมื่อคุณเรียงภาพ / มิเรอร์แล้วลองแล้วทำให้มันไม่สร้าง

หวังว่านี่จะช่วยได้

รุ่นแรกของคำตอบนี้ผิดฉันได้อัปเดตแล้ว

วิธีที่ผมใช้ประสบความสำเร็จคือทำให้เสียงโดเมนกระเบื้อง กล่าวอีกนัยหนึ่งทำให้noise2()ฟังก์ชันพื้นฐานของคุณเป็นระยะ ถ้าnoise2()เป็นระยะและเป็นจำนวนเต็มทำให้เกิดเสียงจะมีช่วงเวลาเดียวกับที่betanoise2()

เราจะทำให้noise2()เป็นระยะได้อย่างไร ในการใช้งานส่วนใหญ่ฟังก์ชั่นนี้ใช้เสียงขัดแตะบางชนิด นั่นคือมันจะได้รับตัวเลขสุ่มที่พิกัดจำนวนเต็มและสอดแทรกพวกมัน ตัวอย่างเช่น:

function InterpolatedNoise_1D(float x)

  integer_X    = int(x)
  fractional_X = x - integer_X

  v1 = SmoothedNoise1(integer_X)
  v2 = SmoothedNoise1(integer_X + 1)

  return Interpolate(v1 , v2 , fractional_X)

end function

ฟังก์ชันนี้สามารถแก้ไขได้เล็กน้อยเพื่อให้เป็นงวดกับช่วงจำนวนเต็ม เพียงเพิ่มหนึ่งบรรทัด:

integer_X = integer_X % Period

ก่อนที่จะคำนวณและv1 v2ด้วยวิธีนี้ค่าที่พิกัดจำนวนเต็มจะทำซ้ำทุกหน่วยของระยะเวลาและการแก้ไขจะทำให้แน่ใจว่าฟังก์ชันที่ได้จะเป็นไปอย่างราบรื่น

อย่างไรก็ตามโปรดทราบว่าวิธีนี้ใช้ได้เฉพาะกับช่วงเวลาที่มีค่ามากกว่า 1 เท่านั้นดังนั้นหากต้องการใช้สิ่งนี้ในการสร้างพื้นผิวที่ไร้รอยต่อคุณจะต้องลองสี่เหลี่ยมจตุรัส x เป็นระยะเวลาไม่ใช่ 1x1

อีกทางเลือกหนึ่งคือการสร้างเสียงรบกวนโดยใช้ไลบรารี libnoise คุณสามารถสร้างเสียงรบกวนในพื้นที่ทางทฤษฎีที่ไม่มีที่สิ้นสุดอย่างราบรื่น

ดูที่ต่อไปนี้: http://libnoise.sourceforge.net/tutorials/tutorial3.html#tile

นอกจากนี้ยังมีพอร์ต XNA ด้านบนที่: http://bigblackblock.com/tools/libnoisexna

หากคุณลงเอยด้วยการใช้พอร์ต XNA คุณสามารถทำสิ่งนี้ได้:

Perlin perlin = new Perlin();
perlin.Frequency = 0.5f;                //height
perlin.Lacunarity = 2f;                 //frequency increase between octaves
perlin.OctaveCount = 5;                 //Number of passes
perlin.Persistence = 0.45f;             //
perlin.Quality = QualityMode.High;
perlin.Seed = 8;

//Create our 2d map
Noise2D _map = new Noise2D(CHUNKSIZE_WIDTH, CHUNKSIZE_HEIGHT, perlin);

//Get a section
_map.GeneratePlanar(left, right, top, down);

GeneratePlanar เป็นฟังก์ชั่นการโทรเพื่อรับหัวข้อในแต่ละทิศทางที่จะเชื่อมต่ออย่างราบรื่นกับพื้นผิวที่เหลือ

แน่นอนว่าวิธีนี้มีค่าใช้จ่ายสูงกว่าการมีพื้นผิวเดียวที่สามารถใช้ได้กับหลายพื้นผิว หากคุณกำลังมองหาการสร้างพื้นผิวแบบสุ่มขึ้นมาได้สิ่งนี้อาจเป็นสิ่งที่คุณสนใจ

แม้ว่าจะมีคำตอบบางส่วนที่จะใช้ได้ แต่ส่วนใหญ่มีความซับซ้อนช้าและมีปัญหา

สิ่งที่คุณต้องทำคือใช้ฟังก์ชั่นสร้างเสียงรบกวนเป็นระยะ แค่นั้นแหละ!

การดำเนินงานที่ดีเยี่ยมโดเมนสาธารณะบนพื้นฐานของ "ขั้นสูง" อัลกอริทึมเสียง Perlin สามารถพบได้ที่นี่ ฟังก์ชั่นที่คุณต้องการคือ pnoise2 รหัสนี้เขียนขึ้นโดย Stefan Gustavson ซึ่งได้แสดงความคิดเห็นที่ชัดเจนเกี่ยวกับปัญหานี้และวิธีการที่คนอื่นใช้วิธีการที่ผิด ฟังกุสตาฟสันเขารู้ว่าเขากำลังพูดถึงอะไร

เกี่ยวกับการคาดการณ์ทรงกลมต่าง ๆ ที่บางคนแนะนำ: เอาล่ะพวกมันทำงานในสาระสำคัญ (ช้าๆ) แต่พวกมันยังผลิตพื้นผิว 2D ที่เป็นทรงกลมแบนเพื่อที่ขอบจะควบแน่นมากขึ้น แน่นอนถ้าคุณตั้งใจให้พื้นผิว 2D ของคุณถูกฉายบนทรงกลมนั่นเป็นวิธีที่จะไป แต่นั่นไม่ใช่สิ่งที่ถูกถาม

นี่เป็นวิธีที่ง่ายกว่ามากในการทำเสียงกระเบื้อง:

คุณใช้การพันแบบแยกส่วนสำหรับแต่ละสเกลของเสียง สิ่งเหล่านี้พอดีกับขอบของพื้นที่ไม่ว่าคุณจะใช้สเกลความถี่ใดก็ตาม ดังนั้นคุณจะต้องใช้เสียง 2D ปกติซึ่งเร็วกว่ามาก นี่คือรหัส WebGL สดซึ่งสามารถดูได้ที่ ShaderToy: https://www.shadertoy.com/view/4dlGW2

ฟังก์ชันสามอันดับแรกทำงานทั้งหมดและ fBM ผ่านเวกเตอร์ x / y ในช่วง 0.0 ถึง 1.0

// Tileable noise, for creating useful textures. By David Hoskins, Sept. 2013.
// It can be extrapolated to other types of randomised texture.

#define SHOW_TILING
#define TILES 2.0

//----------------------------------------------------------------------------------------
float Hash(in vec2 p, in float scale)
{
    // This is tiling part, adjusts with the scale...
    p = mod(p, scale);
    return fract(sin(dot(p, vec2(35.6898, 24.3563))) * 353753.373453);
}

//----------------------------------------------------------------------------------------
float Noise(in vec2 x, in float scale )
{
    x *= scale;

    vec2 p = floor(x);
    vec2 f = fract(x);
    f = f*f*(3.0-2.0*f);
    //f = (1.0-cos(f*3.1415927)) * .5;
    float res = mix(mix(Hash(p,                  scale),
        Hash(p + vec2(1.0, 0.0), scale), f.x),
        mix(Hash(p + vec2(0.0, 1.0), scale),
        Hash(p + vec2(1.0, 1.0), scale), f.x), f.y);
    return res;
}

//----------------------------------------------------------------------------------------
float fBm(in vec2 p)
{
    float f = 0.4;
    // Change starting scale to any integer value...
    float scale = 14.0;
    float amp = 0.55;
    for (int i = 0; i < 8; i++)
    {
        f += Noise(p, scale) * amp;
        amp *= -.65;
        // Scale must be multiplied by an integer value...
        scale *= 2.0;
    }
    return f;
}

//----------------------------------------------------------------------------------------
void main(void)
{
    vec2 uv = gl_FragCoord.xy / iResolution.xy;

#ifdef SHOW_TILING
    uv *= TILES;
#endif

    // Do the noise cloud (fractal Brownian motion)
    float bri = fBm(uv);

    bri = min(bri * bri, 1.0); // ...cranked up the contrast for no reason.
    vec3 col = vec3(bri);

#ifdef SHOW_TILING
    vec2 pixel = (TILES / iResolution.xy);
    // Flash borders...
    if (uv.x > pixel.x && uv.y > pixel.y                                        // Not first pixel
    && (fract(uv.x) < pixel.x || fract(uv.y) < pixel.y) // Is it on a border?
    && mod(iGlobalTime-2.0, 4.0) < 2.0)                 // Flash every 2 seconds
    {
        col = vec3(1.0, 1.0, 0.0);
    }
#endif
    gl_FragColor = vec4(col,1.0);
}

ฉันมีผลลัพธ์ที่ไม่เลวร้ายสอดแทรกอยู่ใกล้กับขอบของแผ่นกระเบื้อง (ขอบห่อ) แต่ขึ้นอยู่กับเอฟเฟกต์ที่คุณพยายามจะทำและพารามิเตอร์เสียงรบกวน ใช้งานได้ดีสำหรับเสียงที่ค่อนข้างพร่ามัวไม่ค่อยดีนักกับ spikey / fine-grained

ฉันกำลังตรวจสอบหัวข้อนี้เพื่อค้นหาคำตอบของปัญหาที่คล้ายกันจากนั้นฉันได้โซลูชันที่สะอาดและกะทัดรัดจากผู้พัฒนาโค้ดไพ ธ อนนี้เพื่อสร้างเสียงเศษส่วนจากเสียงเพอร์ลิน / ซิมเพล็กซ์ รหัสที่อัปเดตมีให้ในปัญหานี้ (ปิด)และสามารถดำเนินการต่อในการตั้งค่าการไล่ระดับสีสำหรับด้านขวาของ "ตัวสร้าง" เท่ากับที่อยู่ทางด้านซ้าย (และเหมือนกันสำหรับด้านบนและด้านล่าง) เช่นใน

# Gradients
angles = 2*np.pi*np.random.rand(res[0]+1, res[1]+1)
gradients = np.dstack((np.cos(angles), np.sin(angles)))
# Make the noise tileable
gradients[-1,:] = gradients[0,:]
gradients[:,-1] = gradients[:,0]

ดูเหมือนว่าเป็นโซลูชันที่หรูหราและสะอาดฉันหลีกเลี่ยงการคัดลอกรหัสทั้งหมดที่นี่ (เนื่องจากไม่ใช่โซลูชันของฉันเอง) แต่มีลิงก์ที่ให้ไว้ด้านบน หวังว่าสิ่งนี้จะเป็นประโยชน์กับคนที่ต้องการสร้างภาพเศษส่วน 2 มิติแบบเศษกระเบื้องที่เป็นรูปเหมือนที่ฉันต้องการนี้โดยปราศจากสิ่งประดิษฐ์หรือการบิดเบือน