¿Cómo se genera ruido de Perlin enlosable?

Relacionado:

• Generación de ruido simple.
• Comprender el ruido Perlin

Me gustaría generar ruido de Perlin enlosable. Estoy trabajando desde las PerlinNoise*() funciones de Paul Bourke , que son así:

// 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);
}

Usando código como:

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

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

Da cielo como

Lo cual no es enlosables.

Los valores de píxel son 0-> 256 (ancho y alto), y el píxel (0,0) usa (x, y) = (0,0) y el píxel (256,256) usa (x, y) = (1,1)

¿Cómo puedo hacerlo enlosable?

Hay dos partes para hacer un ruido fBm perfectamente enlosable como este. Primero, debe hacer que la función de ruido Perlin sea enlosable. Aquí hay un código de Python para una función de ruido Perlin simple que funciona con cualquier período de hasta 256 (puede ampliarlo trivialmente tanto como desee modificando la primera sección):

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))

El ruido de Perlin se genera a partir de una suma de pequeñas "surflets" que son el producto de un gradiente orientado aleatoriamente y una función de caída polinómica separable. Esto da una región positiva (amarillo) y una región negativa (azul)

Las surflets tienen una extensión de 2x2 y se centran en los puntos de la red entera, por lo que el valor del ruido de Perlin en cada punto del espacio se produce sumando las surflets en las esquinas de la celda que ocupa.

Si hace que las direcciones de degradado se envuelvan con un período, el ruido en sí se envolverá sin problemas con el mismo período. Esta es la razón por la cual el código anterior toma el módulo de coordenadas de red el período antes de pasarlo a través de la tabla de permutación.

El otro paso es que al sumar las octavas querrás escalar el período con la frecuencia de la octava. Esencialmente, querrás que cada octava encuadre toda la imagen justa una vez, en lugar de varias veces:

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

Júntalo y obtendrás algo como esto:

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")

Como puede ver, esto realmente se combina perfectamente:

Con algunos pequeños ajustes y mapeo de colores, aquí hay una imagen de nube en mosaico 2x2:

¡Espero que esto ayude!

Aquí hay una forma bastante inteligente que utiliza el ruido 4D Perlin.

Básicamente, asigne la coordenada X de su píxel a un círculo 2D, y la coordenada Y de su píxel a un segundo círculo 2D, y coloque esos dos círculos ortogonales entre sí en el espacio 4D. La textura resultante es enlosable, no tiene una distorsión obvia y no se repite como lo haría una textura reflejada.

Copiar y pegar código del artículo:

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

Ok, lo tengo La respuesta es caminar en un toro en ruido 3D, generando una textura 2D a partir de él.

Código:

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 ;
}

Resultados:

Una vez:

Y azulejos:

Una forma simple en la que puedo pensar sería tomar la salida de la función de ruido y reflejarla / voltearla en una imagen que sea dos veces el tamaño. Es difícil de explicar, así que aquí hay una imagen:

Ahora, en este caso, es bastante obvio lo que hiciste al mirar esto. Se me ocurren dos formas de (posiblemente :-)) resolver esto:

1. Podrías tomar esa imagen más grande y luego generar algo más de ruido encima, pero (y no estoy seguro de si esto es posible) enfocado hacia el medio (para que los bordes permanezcan igual). Podría agregar la diferencia adicional que haría que su cerebro piense que no se trata solo de imágenes especulares.

2. (Tampoco estoy seguro de si esto es posible) Podría intentar jugar con las entradas a la función de ruido para generar la imagen inicial de manera diferente. Tendría que hacer esto por prueba y error, pero busque características que le llamen la atención cuando lo coloque en mosaico / espejo y luego intente que no se generen.

Espero que esto ayude.

La primera versión de esta respuesta fue realmente incorrecta, la actualicé

Un método que utilicé con éxito es hacer mosaico del dominio de ruido . En otras palabras, haga que su base noise2()funcione periódicamente. Si noise2()es periódico y betaes entero, el ruido resultante tendrá el mismo período que noise2().

¿Cómo podemos hacer noise2()periódicos? En la mayoría de las implementaciones, esta función utiliza algún tipo de ruido de red. Es decir, obtiene números aleatorios en coordenadas enteras y las interpola. Por ejemplo:

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

Esta función se puede modificar trivialmente para que sea periódica con un período entero. Simplemente agregue una línea:

integer_X = integer_X % Period

antes de calcular v1y v2. De esta manera, los valores en coordenadas enteras se repetirán en todas las unidades del período, y la interpolación asegurará que la función resultante sea fluida.

Sin embargo, tenga en cuenta que esto solo funciona cuando el Período es mayor que 1. Por lo tanto, para usar esto realmente en la creación de texturas perfectas, tendría que muestrear un cuadrado Período x Período, no 1x1.

Otra alternativa es generar ruido utilizando las bibliotecas libnoise. Puede generar ruido sobre una cantidad teórica infinita de espacio, sin problemas.

Eche un vistazo a lo siguiente: http://libnoise.sourceforge.net/tutorials/tutorial3.html#tile

También hay un puerto XNA de lo anterior en: http://bigblackblock.com/tools/libnoisexna

Si termina usando el puerto XNA, puede hacer algo como esto:

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 es la función a la que se llama para obtener las secciones en cada dirección que se conectarán sin problemas con el resto de las texturas.

Por supuesto, este método es más costoso que simplemente tener una sola textura que se puede usar en múltiples superficies. Si está buscando crear algunas texturas en mosaico al azar, esto puede ser algo que le interese.

Aunque hay algunas respuestas aquí que funcionarían, la mayoría de ellas son complicadas, lentas y problemáticas.

Todo lo que realmente necesita hacer es usar una función periódica de generación de ruido. ¡Eso es!

Aquí se puede encontrar una excelente implementación de dominio público basada en el algoritmo de ruido "avanzado" de Perlin . La función que necesita es pnoise2. El código fue escrito por Stefan Gustavson, quien ha hecho un comentario puntual aquí sobre exactamente este problema y cómo otros han tomado el enfoque equivocado. Escucha a Gustavson, él sabe de lo que está hablando.

Con respecto a las diversas proyecciones esféricas, algunos aquí han sugerido: bueno, en esencia funcionan (lentamente), pero también producen una textura 2D que es una esfera aplanada, de modo que los bordes se condensarían más, probablemente produciendo un efecto no deseado. Por supuesto, si tiene la intención de que su textura 2D se proyecte en una esfera, ese es el camino a seguir, pero eso no es lo que se le pidió.

Aquí hay una forma mucho más simple de hacer ruido en mosaico:

Utiliza una envoltura modular para cada escala del ruido. Estos se ajustan a los bordes del área sin importar la escala de frecuencia que use. Por lo tanto, solo tiene que usar ruido 2D normal, que es mucho más rápido. Aquí está el código WebGL en vivo que se puede encontrar en ShaderToy: https://www.shadertoy.com/view/4dlGW2

Las tres funciones principales hacen todo el trabajo, y fBM pasa un vector x / y en un rango de 0.0 a 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);
}

Tuve algunos resultados no malos que se interpolaron cerca de los bordes del mosaico (envuelto en el borde), pero depende del efecto que intente lograr y los parámetros de ruido exactos. Funciona muy bien para el ruido algo borroso, no tan bueno con los puntiagudos / de grano fino.

Estaba revisando este hilo en busca de una respuesta a un problema similar, luego obtuve una solución limpia y compacta del desarrollador de este código python para generar ruido fractal a partir del ruido perlin / simplex. El código actualizado se proporciona en este tema (cerrado) y se puede reanudar al configurar los gradientes para el lado derecho del "generador" iguales a los del lado izquierdo (e igual para arriba y abajo), como en

# 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]

Parece una solución elegante y limpia, evito copiar todo el código aquí (ya que no es mi propia solución), pero está disponible en el enlace anterior. Espero que esto pueda ser útil para alguien que busque producir una imagen fractal en mosaico 2D como esta que necesitaba, sin artefactos ni distorsiones.