Pequeñas desviaciones sobre el comportamiento rígido y geométrico pueden acercarnos a formas orgánicas. 

Utilizamos la función "random" para obtener valores aleatorios. 
float x;
x = random(10);

El valor puede estar entre 0 y 9,99999_ , nunca alcanza el número límite que incluimos como parámetro.

Nos devuelve un valor con decimales. Si necesitamos un entero, tenemos que eliminar los decimales.
int x;
x = int( random(10) ); // de 0 a 9

Si queremos que empiece en 1, podemos sumar 1:
int x;
x = 1 + int( random(6) ); // se comporta como un dado, de 1 a 6

El ordenador es incapaz de generar números realmente aleatorios, utiliza una tabla de números pseudo-aleatorios para ofrecernos resultados lo bastante aleatorios para la mayoría de los casos.
En búsqueda de mayor aleatoriedad, podemos recurrir a reiniciar el contador de random con un valor que provenga de sucesos en el mundo real impredecibles, por ejemplo el valor del reloj en milisegundos:

randomSeed ( millis() );

Por el contrario, podemos utilizar una aleatoriedad siempre repetida si utilizamos una semilla fija:

randomSeed ( 67 );


Ruido
Con la función random obtenemos valores aleatorios pero sin relación entre si. Cuando necesitamos que la aleatoriedad transcurra suavemente desde unos valores hacia otros, utilizamos el ruido de Perlin (Perlin noise).

float xoff;
void setup() {
 stroke(0, 20);
}
void draw() {
//background(204);
 xoff = xoff + .03;
 float n = noise(xoff) * width;
 line(n, 0, n, height);
}

Se comporta de forma diferente: nos da el valor de ruido, en una localización concreta. Esta localización puede ser en 1, 2 o 3 dimensiones. Según el número de parámetros que le proporcionemos, estaremos usando la función con ese número de dimensiones. 
Puede ayudarnos a comprenderlo imaginar el ruido como un bloque de marmol lleno de vetas grises y oscuras, con matices variados. Podemos medir el valor a lo largo de una línea, con la ayuda de una regla, o podemos medir el valor en su superficie, con las coordenadas de ancho y altura de cada punto, o medir el valor en cualquier punto, incluido su interior, en el espacio tridimensional. Como podemos visualizar, las vetas continúan por el interior de toda la masa de marmol, con total continuidad.

El ruido de Perlin es muy útil para crear superficies irregulares de aspecto natural, por ejemplo paisajes virtuales.


Máquinas de dibujo aleatorio

Utilizando random o noise podemos crear dibujos aleatorios.
Simples puntos aleatorios:

float x,y;

void setup() {
  size(400,300);
  x=width/2;
  y=height/2;
}

void draw () {
  x= random(width);
  y= random(height);
  point(x,y);
}

 

 

Si queremos que cada punto esté en relación con anterior, añadiremos aleatoriedad a las coordenadas de dibujo del punto anterior. Cada nuevo punto no aparece en cualquier lugar de la pantalla, sino cerca del anterior, con lo que empiezan a aparecer zonas densas:

float x, y, inc;

void setup() {
  background(255);
  smooth();
  size(400, 300);
  x=width/2;
  y=height/2;
  inc=6; // salto máximo entre punto y punto
  fill(255, 90);
  stroke(40, 40, 255,40);
}

void draw () {
  x= x+random(-inc, inc);
  y= y+random(-inc, inc);
  point( x, y);
}

 

 

Podemos trazar líneas de un punto a otro para crear un trazo contínuo.

float x, y, inc, oldX, oldY;

void setup() {
  background(255);
  smooth();
  size(400, 300);
  x=width/2;
  y=height/2;
  inc=6; // salto máximo entre punto y punto
  oldX=x;
  oldY=y;
  fill(255, 90);
  stroke(40, 40, 255,40);
}

void draw () {
  x= x+random(-inc, inc);
  y= y+random(-inc, inc);
  line(oldX, oldY, x, y);
  oldX=x;
  oldY=y;
}

 

Este tipo de aleatoriedad, en que cada punto parte del anterior, se denomina ruido Browniano.
Si queremos evitar que el dibujo salga del lienzo, tenemos que incluir unas comprobaciones 'if' que en ese caso vuelvan a situar x e y en el centro, o simplemente impidan que salgan estableciendo ese límite.

 

 

Algunos ejemplos

 

// otra máquina dibujante: traza líneas entre 2 puntos aleatorios, 
// que se generan en 2 zonas separadas

int x1, x2, y1, y2;
  

void setup() {
  size(800, 600);
  background(255);
  smooth();
  stroke(0,20);
  }

void draw() {
  x1=100 + int(random(80));
  x2=700 - int(random(80));
  y1=50 + int(random(500));
  y2=50 + int(random(500));
  line(x1,y1,x2,y2);
  }

 

 

// otra máquina dibujante traza líneas con trazo variable

float x, y, inc, oldX, oldY, grosor;
int counter;

void setup() {
    background(255);
    colorMode(HSB, 100);
    smooth();
    size(400, 300);
    x=width/2;
    y=height/2;
    grosor=1;
    inc=18; // salto máximo entre punto y punto
    oldX=x;
    oldY=y;
    counter=0; // contador para cambio de trazo
    fill(255, 90);
    stroke(40, 40, 255);
    }

void draw () {
    counter++;
    print(counter+" ");
    if (counter>100){
      stroke(random(255), 120,160,20); // cambia el color del trazo
      counter=0;
    }
    grosor=grosor+random(-0.1, 0.1); // cambia el grosor del trazo
    if (grosor<0){
      grosor =2; 
    }
    x= x+random(-inc, inc);
    y= y+random(-inc, inc);
    if (x>width || x<0) { // se sale de la pantalla en x
      seSale();
    }
    if (y>height || y<0) { // se sale de la pantalla en y
      seSale();
    }
    strokeWeight(grosor);
    stroke(0,4);
    line(oldX, oldY, x, y);
    point(x, y);
    noStroke();
    ellipse(x, y, random(2, 8), random(2, 8));
    oldX=x;
    oldY=y;
    }

void seSale() {
    inc=int(random(4, 20));
    x=width/2;
    y=height/2;
    oldX=x;
    oldY=y;
    stroke(random(255), 120,160,20);
    }