Tweetable Mathematical Art [cerrado]

330

Las matemáticas enteras pueden generar patrones sorprendentes cuando se distribuyen sobre una cuadrícula. ¡Incluso las funciones más básicas pueden producir diseños increíblemente elaborados!

Tu reto

Escriba 3 cuerpos de función Tweetable (que significa 140 caracteres o menos) para los valores rojo, verde y azul para una imagen de 1024x1024.

La entrada a las funciones será dos enteros i (número de columna para el píxel dado) y j (número de fila para el píxel dado) y la salida será un corto sin signo entre 0 y 1023, inclusive, que representa la cantidad de color presente en el píxel (i, j).

Por ejemplo, las siguientes tres funciones producen la siguiente imagen:

/* RED */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)*_sq(j-DIM/2))*2.0);
/* GREEN */
    return (unsigned short)sqrt((double)(
        (_sq(i-DIM/2)|_sq(j-DIM/2))*
        (_sq(i-DIM/2)&_sq(j-DIM/2))
    )); 
/* BLUE */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)&_sq(j-DIM/2))*2.0);

Patrón-1

/* RED */
    return i&&j?(i%j)&(j%i):0;
/* GREEN */
    return i&&j?(i%j)+(j%i):0;
/* BLUE */
    return i&&j?(i%j)|(j%i):0;

Patrón-2

Las normas

  • Dado este código C ++ , sustituya en sus funciones. He proporcionado algunas macros y he incluido la biblioteca, y puede incluir complex.h. Puede usar cualquier función de estas bibliotecas y / o mis macros. No utilice ningún recurso externo más allá de esto.
  • Si esa versión no funciona para usted, asegúrese de estar compilando con:

    g++ filename.cpp -std=c++11
    

    Si eso no funciona, utilice la versión alternativa con caracteres sin signo en lugar de cortos sin signo.

Michaelangelo ha proporcionado una versión limpia de salida de color de 24 o 48 bits .

  • Puede implementar su propia versión en otro idioma, pero debe comportarse de la misma manera que la versión de C ++ provista, y solo las funciones de las funciones integradas de C ++, la biblioteca o las macros proporcionadas pueden usarse para hacerlo justo.
  • Publique solo sus tres cuerpos de funciones; no incluya mi código en su publicación
  • Incluya una versión más pequeña o una copia incrustada de su imagen. Están hechos en un formato de ppm y es posible que necesiten convertirse a otro para una visualización adecuada en stackexchange.
  • Los cuerpos de las funciones (sin incluir la firma) deben tener 140 caracteres o menos.
  • Este es un concurso de popularidad: la mayoría de los votos gana
Kyle McCormick
fuente
3
Se agregó la etiqueta C ++ porque la naturaleza de las reglas excluye otros lenguajes. Por lo general, preferimos los desafíos independientes del idioma a menos que tengan una buena razón para requerir un conjunto específico.
algorithmshark
44
Para los votantes cercanos que llaman a esto demasiado amplio, intente escribir una respuesta a esto primero. Es sorprendentemente restrictivo ...
trichoplax
8
¡Esta es mi cosa favorita que he visto aquí, como nunca!
David Conrad el
44
Me encanta que esta pregunta se sienta como una escena de demostración de la vieja escuela.
mskfisher
23
Este tipo de pregunta fomenta la participación en el código de golf . En general, no estoy dispuesto a responder una pregunta directa de golf, ya que no estoy seguro de hacerlo bien. Con este tipo de preguntas, el límite de bytes me hace probar una respuesta simple, aprender técnicas de golf en el camino y luego usarlas para obtener respuestas más complejas. Esto es como un trampolín para responder preguntas directas de golf. Creo que podría ser clave para atraer a más personas.
trichoplax

Respuestas:

120

Mandelbrot 3 x 133 caracteres

Lo primero que me vino a la mente fue "Mandelbrot!".

Sí, sé que ya hay una presentación de Mandelbrot. Después de confirmar que puedo obtener menos de 140 caracteres, he tomado los trucos y las optimizaciones de esa solución en la mía (gracias Martin y Todd). Eso dejó espacio para elegir una ubicación interesante y hacer zoom, así como un buen tema de color:

Mandelbrot

unsigned char RD(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,3.);
}
unsigned char GR(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.7);
}
unsigned char BL(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.5);
}

132 caracteres en total

Traté de bajarlo a 140 para los 3 canales. Hay un poco de ruido de color cerca del borde, y la ubicación no es tan interesante como la primera, pero: 132 caracteres

Mandelbrot-reducido

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}
Manuel Kasten
fuente
8
¡Esos colores son preciosos!
Martin Ender
¡Me encanta esta, la mejor imagen aún!
Roy van Rijn
44
Este es mi fondo de pantalla ahora.
Cipher
209

Manteles

Plano

Comencé poniendo un patrón de cuadros / cuadros en perspectiva como un mantel sin límites:

unsigned char RD(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}

mantel plano

Onda

Luego introduje una onda (perspectiva no estrictamente correcta, pero aún en 140 caracteres):

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}

mantel ondulado

Color

Luego hice algunos de los colores más finos para dar detalles en una gama más amplia de escalas y hacer que la imagen sea más colorida ...

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;
}

mantel de color

En movimiento

Reducir el código un poco más permite definir una fase de onda P con 2 decimales, lo cual es suficiente para cuadros lo suficientemente cercanos como para una animación suave. Reduje la amplitud en esta etapa para evitar provocar mareos, y cambié la imagen completa otros 151 píxeles (al costo de 1 carácter adicional) para eliminar el alias de la parte superior de la imagen. El alias animado es fascinante.

unsigned char RD(int i,int j){
#define P 6.03
float s=3./(j+250),y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;}

unsigned char GR(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;}

unsigned char BL(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;}

mantel animado

trichoplax
fuente
15
Esto es legendario (Y) Sigue así. : P
Mohammad Areeb Siddiqui
Pero, ¿cómo se implementa exactamente el movimiento? En el marco original no hay lógica de cambio de marco, ¿verdad?
esteewhy
2
@esteepor qué solo se pueden producir imágenes fijas. El GIF muestra una secuencia de cuadros fijos, cada uno de los cuales se produjo al cambiar el valor después #define P. Se requería jugar golf para permitir los caracteres adicionales #define P 6.03.
trichoplax
44
¡DETENER! ¿Realmente quieres votar la respuesta más importante? Hay algunas muy lejos los más interesantes si se desplaza hacia abajo a través de las dos páginas siguientes.
trichoplax
1
Recomiendo clasificar las respuestas por "más antiguo" y entonces usted puede ver cómo los nuevos enfoques desarrollados como nuevas respuestas entraron.
Trichoplax
192

Pintor al azar

ingrese la descripción de la imagen aquí

char red_fn(int i,int j){
#define r(n)(rand()%n)
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):red_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char green_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):green_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char blue_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):blue_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}

Aquí hay una entrada basada en la aleatoriedad. Para aproximadamente el 0.1% de los píxeles elige un color aleatorio, para los demás usa el mismo color que un píxel adyacente aleatorio. Tenga en cuenta que cada color hace esto de forma independiente, por lo que en realidad es solo una superposición de una imagen aleatoria de verde, azul y rojo. Para obtener diferentes resultados en diferentes ejecuciones, deberá agregar srand(time(NULL))a la mainfunción.

Ahora para algunas variaciones.

Al omitir píxeles, podemos hacerlo un poco más borroso.

ingrese la descripción de la imagen aquí

Y luego podemos cambiar lentamente los colores, donde los desbordamientos resultan en cambios abruptos que hacen que esto se vea aún más como pinceladas

ingrese la descripción de la imagen aquí

Cosas que necesito resolver:

  • Por alguna razón, no puedo poner sranddentro de esas funciones sin obtener un segfault.
  • Si pudiera hacer que las caminatas aleatorias sean las mismas en los tres colores, podría parecer un poco más ordenado.

También puede hacer que la caminata aleatoria sea isotrópica, como

static char c[1024][1024];return!c[i][j]?c[i][j]=r(999)?red_fn((i+r(5)+1022)%1024,(j+r(5)+1022)%1024):r(256):c[i][j];

darte

ingrese la descripción de la imagen aquí

Más cuadros al azar

He jugado un poco más con esto y he creado algunas otras pinturas al azar. No todos estos son posibles dentro de las limitaciones de este desafío, por lo que no quiero incluirlos aquí. Pero puedes verlos en esta galería de imágenes junto con algunas descripciones de cómo los produje .

Estoy tentado a desarrollar todas estas posibilidades en un marco y ponerlo en GitHub. (No es que cosas como esta aún no existan, ¡pero es divertido de todos modos!)

Martin Ender
fuente
12
Me encantan estos. No me había dado cuenta de que sería posible tener en cuenta los píxeles adyacentes sin tener acceso a los datos de píxeles: ¡un trabajo sin problemas!
trichoplax
1
Me recuerda mucho a este viejo concurso donde las reglas eran poner un píxel de cada color en la imagen.
interconexiones están hechas de catz el
2
¡Guauu! ¡Estas fotos son absolutamente hermosas!
raptortech97
1
Galería genial, las radiales están ordenadas.
interconexiones están hechas de catz
2
Veo Reptar : última imagen en la publicación (la isotrópica), cuadrante superior derecho.
Tim Pederick
162

Algunas cosas puntiagudas

Sí, sabía exactamente cómo llamarlo.

Algunas cosas puntiagudas

unsigned short RD(int i,int j){
    return(sqrt(_sq(73.-i)+_sq(609-j))+1)/(sqrt(abs(sin((sqrt(_sq(860.-i)+_sq(162-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(160.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(86.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(844.-i)+_sq(200-j))+1)/(sqrt(abs(sin((sqrt(_sq(250.-i)+_sq(20-j)))/115.0)))+1)/200;
}

EDITAR: ya no se usa pow. EDIT 2: @PhiNotPi señaló que no necesito usar abdominales tanto.

Puede cambiar los puntos de referencia con bastante facilidad para obtener una imagen diferente:

Algunas cosas más puntiagudas

unsigned short RD(int i,int j){
    return(sqrt(_sq(148.-i)+_sq(1000-j))+1)/(sqrt(abs(sin((sqrt(_sq(500.-i)+_sq(400-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(610.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(864.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(180.-i)+_sq(100-j))+1)/(sqrt(abs(sin((sqrt(_sq(503.-i)+_sq(103-j)))/115.0)))+1)/200;
}

@EricTressler señaló que mis fotos tienen Batman en ellas.

hombre murciélago

cjfaure
fuente
1
@JayKominek No lo sabría, no estaba en ese entonces d:
cjfaure
1
@cjfaure oh wow! ¡gracias! parece que la versión final de la descripción está en: web.archive.org/web/20031205062033/http://www.blorf.com/~mrad/… y el código se movió a sourceforge. actualizado el año pasado incluso! sourceforge.net/projects/libswirlies
Jay Kominek
1
¡Uno de mis favoritos!
Aficiones de Calvin
1
Este es bonito, ¡pero no puedo reproducirlo en absoluto! Lo más cerca que puedo llegar es cuando el PPM se genera incorrectamente (LSB en lugar de MSB) e incluso entonces parece una variedad de círculos alfa-mezclados de diferentes colores.
DreamWarrior
123

Por supuesto, tiene que haber una presentación de Mandelbrot.

ingrese la descripción de la imagen aquí

char red_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>31?256:k*8;
}
char green_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>63?256:k*4;
}
char blue_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k;
}

Intentando mejorar el esquema de color ahora. ¿Es engañoso si defino el cálculo como una macro red_fny uso esa macro en las otras dos para tener más caracteres para la selección de colores elegantes en verde y azul?

Editar: es realmente difícil crear esquemas de color decentes con estos pocos bytes restantes. Aquí hay otra versión:

/* RED   */ return log(k)*47;
/* GREEN */ return log(k)*47;
/* BLUE  */ return 128-log(k)*23;

ingrese la descripción de la imagen aquí

Y según la sugerencia de los gitofagocitos y con las mejoras de Todd Lehman, podemos elegir fácilmente secciones más pequeñas:

P.ej

char red_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char green_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char blue_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return 128-k/200;
}

da

ingrese la descripción de la imagen aquí

Martin Ender
fuente
12
@tomsmeding Tengo que confesar, esta es la primera vez que implementé el conjunto Mandelbrot.
Martin Ender
2
Tan icónico como es el conjunto completo de Mandelbrot (¡+1, por cierto!), Parece que te has dejado suficiente espacio para ajustar los parámetros y publicar una respuesta con algunos de los detalles increíblemente retorcidos de un zoom profundo.
trichoplax
1
@githubphagocyte Ya pensé en eso, pero aún no me molesté en volver a compilar, volver a ejecutar y convertir cada vez hasta que haya descubierto parámetros decentes;). Podría hacerlo más tarde. Sin embargo, primero tengo que probar una función completamente diferente. ;)
Martin Ender
2
@githubphagocyte finalmente logró agregar eso. ¡Gracias por la sugerencia!
Martin Ender
2
Gracias @Todd, he actualizado la imagen final con eso. Usé 25600 iteraciones, eso fue lo suficientemente largo. ;)
Martin Ender
110

Juegos de julia

Si hay un Mandelbrot, también debería haber un conjunto de Julia.

ingrese la descripción de la imagen aquí

Puede pasar horas ajustando los parámetros y funciones, por lo que este es solo uno rápido que parece decente.

Inspirado en la participación de Martin.

unsigned short red_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.)
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(X=x*x)+(Y=y*y)<4){x=X-Y+.36237;y=2*x*y+.32;}return log(n)*256;}

unsigned short green_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+-.7;y=2*X*Y+.27015;}return log(n)*128;}

unsigned short blue_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<600&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+.36237;y=2*X*Y+.32;}return log(n)*128;}

¿Quieres un poco de RNG?

Bien, el comentario de Sparr me puso en la pista para aleatorizar los parámetros de estas pequeñas Julias. Primero intenté hacer piratería a nivel de bits con el resultado de, time(0)pero C ++ no permite literales hexadecimales de coma flotante, por lo que este fue un callejón sin salida (al menos con mi conocimiento limitado). Podría haber usado un casting pesado para lograrlo, pero eso no habría encajado en los 140 bytes.

No me quedaba mucho espacio de todos modos, así que tuve que soltar la Julia roja para poner mis macros y tener un RNG más convencional ( timed seed y real rand(), ¡woohoo!).

ingrese la descripción de la imagen aquí

Vaya, falta algo. Obviamente, estos parámetros tienen que ser estáticos o, de lo contrario, tendrá algunos resultados extraños (pero divertido, tal vez investigaré un poco más tarde si encuentro algo interesante).

Así que aquí estamos, con solo canales verdes y azules:

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Ahora agreguemos un patrón rojo simple para llenar el vacío. No es realmente imaginativo, pero no soy un programador gráfico ... todavía :-)

ingrese la descripción de la imagen aquí

ingrese la descripción de la imagen aquí

Y finalmente el nuevo código con parámetros aleatorios:

unsigned short red_fn(int i, int j){
static int n=1;if(n){--n;srand(time(0));}
#define R rand()/16384.-1
#define S static float r=R,k=R;float
return _cb(i^j);}

unsigned short green_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.),
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

unsigned short blue_fn(int i, int j){
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

Todavía queda espacio ahora ...

las interconexiones están hechas de catz
fuente
¿tiene espacio para aleatorizar los parámetros cada ejecución con srand (time (0) y rand ()? o solo time (0)?
Sparr
2
Ese último va a mi pared.
cjfaure
@Sparr actualizado con su sugerencia. Me divertí un poco :-).
interconexiones están hechas de catz el
44
No puedo decir qué es lo que más te gusta: tu respuesta o tu nombre de usuario
William Barbosa
107

Este es interesante porque no utiliza los parámetros i, j en absoluto. En cambio, recuerda el estado en una variable estática.

unsigned char RD(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char GR(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char BL(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}

vistoso

Manuel Kasten
fuente
Sería interesante ver los resultados de este código en diferentes plataformas / compiladores. El valor de RAND_MAX varía ampliamente y podría dar imágenes completamente diferentes ...
trichoplax
55
No debería cambiar mucho. (double) rand () / RAND_MAX siempre debe estar en el rango [0.0, 1.0].
Manuel Kasten
2
¡Este es uno de mis favoritos!
Aficiones de Calvin
2
No solo es interesante, ¡es hermoso!
Martin Thoma
104

Imagen

/* RED */
    int a=(j?i%j:i)*4;int b=i-32;int c=j-32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
/* GREEN */
    int a=(j?i%j:i)*4;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((i+j)/2))^_cb((i-j)*2);
/* BLUE */
    int a=(j?i%j:i)*4;int b=i+32;int c=j+32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
faubi
fuente
3
Eso es realmente hermoso, +1.
Milo
3
Este es mi favorito. Parece una pieza de diseño gráfico hecha profesionalmente. : D
cjfaure
44
Parece una oblea de microprocesadores. macrophotographer.net/images/ss_rvsi_5.jpg
s0rce
1
Se ve similar al logotipo del arco iris de Apple .
LegionMammal978
82

Buddhabrot (+ Antibuddhabrot)

Editar: ¡ Ahora es un Buddhabrot apropiado!

Editar: logré limitar la intensidad del color dentro del límite de bytes, por lo que no hay más píxeles falsamente negros debido al desbordamiento.

Tenía muchas ganas de parar después de las cuatro ... pero ...

ingrese la descripción de la imagen aquí

Esto se comprime ligeramente durante la carga (y se reduce al incrustar), por lo que si desea admirar todos los detalles, aquí está el interesante 512x512 recortado (que no se comprime y se muestra en su tamaño completo):

ingrese la descripción de la imagen aquí

Gracias a githubphagocyte por la idea. Esto requirió un abuso bastante complicado de las tres funciones de color:

unsigned short RD(int i,int j){
    #define f(a,b)for(a=0;++a<b;)
    #define D float x=0,y=0
    static int z,m,n;if(!z){z=1;f(m,4096)f(n,4096)BL(m-4096,n-4096);};return GR(i,j);
}
unsigned short GR(int i,int j){
    #define R a=x*x-y*y+i/1024.+2;y=2*x*y+j/1024.+2
    static float c[DIM][DIM],p;if(i>=0)return(p=c[i][j])>DM1?DM1:p;c[j+DIM][i/2+DIM]+=i%2*2+1;
}
unsigned short BL(int i,int j){
    D,a,k,p=0;if(i<0)f(k,5e5){R;x=a;if(x*x>4||y*y>4)break;GR(int((x-2)*256)*2-p,(y-2)*256);if(!p&&k==5e5-1){x=y=k=0;p=1;}}else{return GR(i,j);}
}

Quedan algunos bytes para un mejor esquema de color, pero hasta ahora no he encontrado nada que supere la imagen en escala de grises.

El código que se proporciona utiliza 4096x4096 puntos de partida y realiza hasta 500,000 iteraciones en cada uno de ellos para determinar si las trayectorias escapan o no. Eso tomó entre 6 y 7 horas en mi máquina. Puede obtener resultados decentes con una cuadrícula de 2k por 2k y 10k iteraciones, lo que lleva dos minutos, e incluso solo una cuadrícula de 1k por 1k con 1k iteraciones se ve bastante bien (eso lleva unos 3 segundos). Si desea jugar con esos parámetros, hay algunos lugares que deben cambiar:

  • Para cambiar el nivel de recursividad de Mandelbrot, ajuste ambas instancias de 5e5en BLa su cuenta de iteración.
  • Para cambiar la resolución de la cuadrícula, cambiar los cuatro 4096en RDque la resolución deseada y 1024.en GRel mismo factor para mantener la escala correcta.
  • Es probable que también tenga que escalar la return c[i][j]en GRya que sólo contiene el número absoluto de visitas de cada píxel. El color máximo parece ser mayormente independiente del recuento de iteraciones y se escala linealmente con el número total de puntos de partida. Entonces, si desea usar una cuadrícula de 1k por 1k, es posible que desee return c[i][j]*16;o similar, pero ese factor a veces necesita un poco de violín.

Para aquellos que no están familiarizados con el Buddhabrot (como yo hace un par de días), se basa en el cálculo de Mandelbrot, pero la intensidad de cada píxel es la frecuencia con la que se visitó ese píxel en las iteraciones de las trayectorias de escape. Si estamos contando las visitas durante las trayectorias que no escapan, es un Antibuddhabrot. Existe una versión aún más sofisticada llamada Nebulabrot, donde utiliza una profundidad de recursión diferente para cada canal de color. Pero se lo dejaré a otra persona. Para más información, como siempre, Wikipedia .

Originalmente, no distinguí entre las trayectorias de escape y las de no escape. Eso generó una trama que es la unión de un Buddhabrot y un Antibuddhabrot (como lo señala el githubphagocyte).

unsigned short RD(int i,int j){
    #define f(a)for(a=0;++a<DIM;)
    static int z;float x=0,y=0,m,n,k;if(!z){z=1;f(m)f(n)GR(m-DIM,n-DIM);};return BL(i,j);
}
unsigned short GR(int i,int j){
    float x=0,y=0,a,k;if(i<0)f(k){a=x*x-y*y+(i+256.0)/512;y=2*x*y+(j+512.0)/512;x=a;if(x*x+y*y>4)break;BL((x-.6)*512,(y-1)*512);}return BL(i,j);
}
unsigned short BL(int i,int j){
    static float c[DIM][DIM];if(i<0&&i>-DIM-1&&j<0&&j>-DIM-1)c[j+DIM][i+DIM]++;else if(i>0&&i<DIM&&j>0&&j<DIM)return log(c[i][j])*110;
}

ingrese la descripción de la imagen aquí

Esta se parece un poco a una fotografía desvaída ... Me gusta eso.

Martin Ender
fuente
8
Lo convertiré en un sombrero.
cjfaure
66
Estoy realmente asombrado de que hayas reducido esto a 3 lotes de 140 bytes. La nueva imagen de buddabrot es hermosa.
trichoplax
44
Esto es realmente impresionante.
copumpkin
El primero es realmente ingenioso. Me recuerda a las medusas. +1
Igby Largeman
1
Esta es mi presentación favorita. ¡Buen trabajo!
thomallen
76

Pentágono de Sierpinski

Es posible que hayas visto el método del juego del caos para aproximar el Triángulo de Sierpinski al trazar puntos a la mitad de un vértice elegido al azar. Aquí he tomado el mismo enfoque usando 5 vértices. El código más corto en el que podía establecerme incluía la codificación rígida de los 5 vértices, y no había forma de que lo ajustara todo en 140 caracteres. Así que delegué el componente rojo a un fondo simple, y usé el espacio libre en la función roja para definir una macro para que las otras dos funciones también sean inferiores a 140. Entonces, todo es válido a costa de no tener un componente rojo en el pentágono.

unsigned char RD(int i,int j){
#define A int x=0,y=0,p[10]={512,9,0,381,196,981,827,981,DM1,381}
auto s=99./(j+99);return GR(i,j)?0:abs(53-int((3e3-i)*s+j*s)%107);}

unsigned char GR(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<2e7;n++){int v=(rand()%11+1)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

unsigned char BL(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<3e7;n++){int v=(rand()%11+4)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

Gracias a Martin Büttner por la idea mencionada en los comentarios de la pregunta sobre la definición de una macro en una función para luego usarla en otra, y también por usar la memorización para llenar los píxeles en un orden arbitrario en lugar de estar restringida al orden ráster de la función principal .

pentágono

La imagen tiene más de 500 KB, por lo que se convierte automáticamente a jpg por intercambio de pila. Esto difumina algunos de los detalles más finos, por lo que también he incluido solo el cuarto superior derecho como png para mostrar el aspecto original:

parte superior derecha

trichoplax
fuente
73

Partitura

La música de Sierpinski. : D Los chicos en el chat dicen que se parece más al papel perforado para cajas de música.

Partitura

unsigned short RD(int i,int j){
    return ((int)(100*sin((i+400)*(j+100)/11115)))&i;
}
unsigned short GR(int i,int j){
    return RD(i,j);
}
unsigned short BL(int i,int j){
    return RD(i,j);
}

Algunos detalles sobre cómo funciona ... um, en realidad es solo un acercamiento en una representación de algunos triángulos ondulados de Sierpinski. El aspecto de la partitura (y también el bloqueo) es el resultado del truncamiento de enteros. Si cambio la función roja a, digamos,

return ((int)(100*sin((i+400)*(j+100)/11115.0)));

se elimina el truncamiento y obtenemos el render de resolución completa:

Partituras sin bloques

Entonces sí, eso es interesante.

cjfaure
fuente
1
Es como Squarepusher transcrito en neumes
ostensivo ossifrage
1
@squeamishossifrage ¿Qué acabo de ver ...?
cjfaure
:-) Los videos de Chris Cunningham son un poco extraños, ¿no?
aprensivo ossifrage
14
el segundo parece que se mueve cuando
desplazo
55
Al desplazarse por el sitio, el último realmente parecía estar moviéndose. Bonita ilusión óptica.
Kyle Kanos
61

Generador de diagrama de Voronoi al azar alguien

OK, este me hizo pasar un mal rato. Sin embargo, creo que es bastante bueno, incluso si los resultados no son tan artísticos como otros. Ese es el trato con la aleatoriedad. Tal vez algunas imágenes intermedias se vean mejor, pero realmente quería tener un algoritmo completamente funcional con diagramas voronoi.

ingrese la descripción de la imagen aquí

Editar:

ingrese la descripción de la imagen aquí

Este es un ejemplo del algoritmo final. La imagen es básicamente la superposición de tres diagramas voronoi, uno para cada componente de color (rojo, verde, azul).

Código

versión no comentada y comentada al final

unsigned short red_fn(int i, int j){
int t[64],k=0,l,e,d=2e7;srand(time(0));while(k<64){t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short green_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short blue_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

Me tomó muchos esfuerzos, así que tengo ganas de compartir los resultados en diferentes etapas, y hay algunos buenos (incorrectos) para mostrar.

Primer paso: coloque algunos puntos al azar, con x=y

ingrese la descripción de la imagen aquí

Lo he convertido a jpeg porque el png original era demasiado pesado para cargar ( >2MB), ¡apuesto a que son más de 50 tonos de gris!

Segundo: tener una mejor coordenada y

No podía permitirme tener otra tabla de coordenadas generada aleatoriamente para el yeje, por lo que necesitaba una forma simple de obtener las " aleatorias " en la menor cantidad de caracteres posible. Fui a usar la xcoordenada de otro punto en la tabla, haciendo un bit ANDa bit en el índice del punto.

ingrese la descripción de la imagen aquí

3 °: no recuerdo pero se está poniendo bien

Pero en este momento tenía más de 140 caracteres, así que necesitaba jugar golf bastante.

ingrese la descripción de la imagen aquí

4to: líneas de escaneo

Es broma, esto no es deseable, pero me parece genial.

ingrese la descripción de la imagen aquí ingrese la descripción de la imagen aquí

Aún trabajando para reducir el tamaño del algoritmo, me enorgullece presentar:

Edición StarFox

ingrese la descripción de la imagen aquí

Voronoi instagram

ingrese la descripción de la imagen aquí

5to: aumentar el número de puntos

Ahora tengo un código funcional, así que pasemos de 25 a 60 puntos. ingrese la descripción de la imagen aquí

Eso es difícil de ver desde una sola imagen, pero los puntos están casi todos ubicados en el mismo yrango. Por supuesto, no cambié la operación bit a bit, &42es mucho mejor:

ingrese la descripción de la imagen aquí

Y aquí estamos, en el mismo punto que la primera imagen de esta publicación. Ahora expliquemos el código para los raros que estarían interesados.

Código sin golf y explicado

unsigned short red_fn(int i, int j)
{
    int t[64],          // table of 64 points's x coordinate
        k = 0,          // used for loops
        l,              // retains the index of the nearest point
        e,              // for intermediary results
        d = 2e7;        // d is the minimum distance to the (i,j) pixel encoutnered so far
        // it is initially set to 2e7=2'000'000 to be greater than the maximum distance 1024²

    srand(time(0));     // seed for random based on time of run
    // if the run overlaps two seconds, a split will be observed on the red diagram but that is
    // the better compromise I found

    while(k < 64)       // for every point
    {
        t[k] = rand() % DIM;        // assign it a random x coordinate in [0, 1023] range
        // this is done at each call unfortunately because static keyword and srand(...)
        // were mutually exclusive, lenght-wise

        if (
            (e=                         // assign the distance between pixel (i,j) and point of index k
                _sq(i - t[k])           // first part of the euclidian distance
                +
                _sq(j - t[42 & k++])    // second part, but this is the trick to have "" random "" y coordinates
                // instead of having another table to generate and look at, this uses the x coordinate of another point
                // 42 is 101010 in binary, which is a better pattern to apply a & on; it doesn't use all the table
                // I could have used 42^k to have a bijection k <-> 42^k but this creates a very visible pattern splitting the image at the diagonal
                // this also post-increments k for the while loop
            ) < d                       // chekcs if the distance we just calculated is lower than the minimal one we knew
        )
        // {                            // if that is the case
            d=e,                        // update the minimal distance
            l=k;                        // retain the index of the point for this distance
            // the comma ',' here is a trick to have multiple expressions in a single statement
            // and therefore avoiding the curly braces for the if
        // }
    }

    return t[l];        // finally, return the x coordinate of the nearest point
    // wait, what ? well, the different areas around points need to have a
    // "" random "" color too, and this does the trick without adding any variables
}

// The general idea is the same so I will only comment the differences from green_fn
unsigned short green_fn(int i, int j)
{
    static int t[64];       // we don't need to bother a srand() call, so we can have these points
    // static and generate their coordinates only once without adding too much characters
    // in C++, objects with static storage are initialized to 0
    // the table is therefore filled with 60 zeros
    // see http://stackoverflow.com/a/201116/1119972

    int k = 0, l, e, d = 2e7;

    while(k<64)
    {
        if( !t[k] )                 // this checks if the value at index k is equal to 0 or not
        // the negation of 0 will cast to true, and any other number to false
            t[k] = rand() % DIM;    // assign it a random x coordinate

        // the following is identical to red_fn
        if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)
            d=e,l=k;
    }

    return t[l];
}

Gracias por leer hasta ahora.

las interconexiones están hechas de catz
fuente
1
Me encantan los diagramas de Voronoi. ¡+1 por ajustarlo en 3 tweets!
Martin Ender
1
Este es uno de mis favoritos personales. Las variantes de la línea de escaneo son muy agradables estéticamente.
Fraxtil
1
Me encanta cómo explicaste el código
Andrea
¡Haz una tirada de barril!
Starson Hochschild
la segunda foto en 4to: scanlines es hermoso.
Khaled.K
57

El fractal de Lyapunov

Fractal de Lyapunov

La cadena utilizada para generar esto fue AABAB y el espacio del parámetro fue [2,4] x [2,4]. ( explicación de la cadena y el espacio de parámetros aquí )

Con espacio de código limitado, pensé que este color era bastante genial.

    //RED
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s);
    //GREEN
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return s>0?s:0;
    //BLUE
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s*x);

También hice una variación del conjunto de Mandelbrot. Utiliza un mapa similar al conjunto de mapas de Mandelbrot. Digamos que M (x, y) es el mapa de Mandelbrot. Entonces M (sin (x), cos (y)) es el mapa que uso, y en lugar de verificar los valores de escape, uso x e y, ya que siempre están delimitados.

//RED
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 2.5*(x*x+y*y);
//GREEN
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(x);
//BLUE
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(y);

ingrese la descripción de la imagen aquí

EDITAR

Después de mucho dolor finalmente pude crear un gif de la segunda imagen transformándose. Aquí está:

Tiempo de fiesta

Cameron
fuente
11
Bonito aspecto psicodélico para el segundo.
interconexiones están hechas de catz
44
Estos son locos ! +1
cjfaure
10
Scary fractal is scary ༼ ༎ ຶ ෴ ༎ ຶ ༽
Tobia
1
Mierda, ese segundo da miedo. Amaximg cuánto puede obtener de la simple z = z ^ 2 + c.
tomsmeding
44
Si Edward Munch solía pintar fractales, este habría sido el aspecto de The Scream .
interconexiones están hechas de catz el
55

Porque los unicornios.

Porque los unicornios

No pude obtener la versión de OP con unsigned shorty valores de color de hasta 1023 funcionando, así que hasta que se solucione, aquí hay una versión con charun valor de color máximo de 255.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}
Martin Ender
fuente
Me gustaría ver los canales de color individualmente. Eso sería genial.
aplaude el
52

Colinas logísticas

ingrese la descripción de la imagen aquí

Las funciones

unsigned char RD(int i,int j){    
    #define A float a=0,b,k,r,x
    #define B int e,o
    #define C(x) x>255?255:x
    #define R return
    #define D DIM
    R BL(i,j)*(D-i)/D;
}
unsigned char GR(int i,int j){      
    #define E DM1
    #define F static float
    #define G for(
    #define H r=a*1.6/D+2.4;x=1.0001*b/D
    R BL(i,j)*(D-j/2)/D;
}
unsigned char BL(int i,int j){
    F c[D][D];if(i+j<1){A;B;G;a<D;a+=0.1){G b=0;b<D;b++){H;G k=0;k<D;k++){x=r*x*(1-x);if(k>D/2){e=a;o=(E*x);c[e][o]+=0.01;}}}}}R C(c[j][i])*i/D;
}

Sin golf

Todos los #defines son para encajar BL bajo 140 caracteres. Aquí está la versión no adaptada del algoritmo azul, ligeramente modificada:

for(double a=0;a<DIM;a+=0.1){       // Incrementing a by 1 will miss points
    for(int b=0;b<DIM;b++){         // 1024 here is arbitrary, but convenient
        double r = a*(1.6/DIM)+2.4; // This is the r in the logistic bifurcation diagram (x axis)
        double x = 1.0001*b/DIM;    // This is x in the logistic bifurcation diagram (y axis). The 1.0001 is because nice fractions can lead to pathological behavior.
        for(int k=0;k<DIM;k++){
            x = r*x*(1-x);          // Apply the logistic map to x
            // We do this DIM/2 times without recording anything, just to get x out of unstable values
            if(k>DIM/2){
                if(c[(int)a][(int)(DM1*x)]<255){
                    c[(int)a][(int)(DM1*x)]+=0.01; // x makes a mark in c[][]
                } // In the golfed code, I just always add 0.01 here, and clip c to 255
            }
        }            
    }    
}

Donde los valores de x caen con mayor frecuencia para un determinado r (valor j), la gráfica se vuelve más clara (generalmente representada como más oscura).

Eric Tressler
fuente
3
Aww, estaba pensando en cómo hacer esto ayer. +1 por resolverlo. De hecho, creo que la paleta es realmente bonita. :)
Martin Ender
2
Te robé los trucos sucios y los gitofagocitos, aunque me responsabilizo de los feos #defines. Especialmente "#define G for (".
Eric Tressler
1
se parece más a un visualizador de soporte de torneo
Kevin L
3
No se muestra en la parte superior: el ganador muere
Eric Tressler
1
¿Puedo obtener una impresión del tamaño de un póster de esto? Con 3 tweets desvaídos en el fondo. :-)
Andrew Cheong
50

Difusión limitada agregación

Siempre me ha fascinado la agregación limitada por difusión y la cantidad de formas diferentes en que aparece en el mundo real.

Me resultó difícil escribir esto en solo 140 caracteres por función, así que tuve que hacer que el código fuera horrible (o hermoso, si te gustan cosas como ++d%=4y for(n=1;n;n++)). Las tres funciones de color se llaman entre sí y definen macros para que se usen, por lo que no se lee bien, pero cada función tiene poco menos de 140 caracteres.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-(BL(i,j))/2:0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

difusión de agregación limitada

Para visualizar cómo las partículas se agregan gradualmente, produje instantáneas a intervalos regulares. Cada cuadro se produjo reemplazando el 1 en for(n=1;n;n++)con 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Esto lo mantuvo justo por debajo del límite de 140 caracteres para cada ejecución.

agregación animada

Puede ver que los agregados que crecen cerca uno del otro se privan de partículas y crecen más lentamente.


Al hacer un ligero cambio en el código, puede ver las partículas restantes que aún no se han unido a los agregados. Esto muestra las regiones más densas donde el crecimiento ocurrirá más rápidamente y las regiones muy dispersas entre los agregados donde no puede ocurrir más crecimiento debido a que todas las partículas se han agotado.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-BL(i,j):0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

DLA con partículas visibles

Esto se puede animar de la misma manera que antes:

agregación animada con partículas

trichoplax
fuente
3
Muy interesante, +1.
interconexiones están hechas de catz
50

Espiral (140 exactamente)

producto final

Esto es exactamente 140 caracteres si no incluye los encabezados y paréntesis de la función. Es tanta complejidad espiral que podría encajar en el límite de caracteres.

unsigned char RD(int i,int j){
    return DIM-BL(2*i,2*j);
}
unsigned char GR(int i,int j){
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    i-=512;j-=512;int d=sqrt(i*i+j*j);return d+atan2(j,i)*82+sin(_cr(d*d))*32+sin(atan2(j,i)*10)*64;
}

Gradualmente construí una espiral simple, agregué patrones a los bordes de la espiral y experimenté cómo se podían combinar diferentes espirales para que se vieran geniales. Aquí hay una versión sin golf con comentarios que explican lo que hace cada pieza. Jugar con los parámetros puede producir algunos resultados interesantes.

unsigned char RD(int i,int j){
    // *2 expand the spiral
    // DIM- reverse the gradient
    return DIM - BL(2*i, 2*j);
}
unsigned char GR(int i,int j){
    // notice swapped parameters
    // 128 changes phase of the spiral
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    // center it
    i -= DIM / 2;
    j -= DIM / 2;

    double theta = atan2(j,i); //angle that point is from center
    double prc = theta / 3.14f / 2.0f; // percent around the circle

    int dist = sqrt(i*i + j*j); // distance from center

    // EDIT: if you change this to something like "prc * n * 256" where n
    //   is an integer, the spirals will line up for any arbitrarily sized
    //   DIM value, or if you make separate DIMX and DIMY values!
    int makeSpiral = prc * DIM / 2;

    // makes pattern on edge of the spiral
    int waves = sin(_cr(dist * dist)) * 32 + sin(theta * 10) * 64;

    return dist + makeSpiral + waves;
}

Jugar con los parámetros:

Aquí, las espirales están alineadas pero tienen diferentes patrones de borde. En lugar de los bordes en bloque en el ejemplo principal, esto tiene bordes completamente compuestos de ondas sin.

bordes

Aquí, el gradiente ha sido eliminado:

sin gradiente

Una animación ( que por alguna razón no parece estar repitiéndose después de haberla cargado, lo siento. Además, tuve que reducirla. Simplemente ábrala en una nueva pestaña si se perdió la animación ):

animación

Y aquí está el álbum de imgur con todas las imágenes. Me encantaría ver si alguien puede encontrar otros patrones espirales geniales. Además, debo decir que este es, con mucho, uno de los desafíos más geniales que he visto aquí. ¡Disfrutar!

EDITAR: Aquí hay algunos fondos hechos de estas espirales con parámetros alterados.

Además, al combinar mis patrones de borde en espiral con algunos de los fractales que he visto aquí mediante el uso de xor / y / u operaciones, aquí hay una espiral final:

espiral fractal

xleviator
fuente
2
Estos son fantasticos! Si miras las otras respuestas, podrías encontrar ideas para jugar golf aún más si quisieras más espacio. Algunas de las respuestas usan #define en una función para definir una macro que los 3 pueden usar, por lo que puede descargar la mayor parte del cálculo en otras funciones de color. Martin Büttner me presentó ese truco.
Trichoplax
¡Gracias! En mi caso, hasta donde puedo encontrar, mi código carece del tipo de patrones lógicos duplicados que se beneficiarían de las definiciones de libra. Sin embargo, si ve alguno, le agradecería que me los identificara, especialmente al ver que no he usado C / C ++ ampliamente en años.
xleviator
Encontrar secciones duplicadas realmente ayudaría aún más, pero incluso sin ninguna duplicación, simplemente puede mover el código de BL a RD o GN definiéndolo como una macro en RD o GN y luego usándolo en BL. Eso debería darle el doble de espacio para el código adicional.
Trichoplax
Ah! Veo. Ni siquiera me di cuenta de que cada cuerpo de la función tenía el límite de 140 caracteres. Supongo que la próxima vez debería leer el mensaje con más cuidado. ¡Gracias por señalar eso!
xleviator
1
Como se discutió en el chat , su GIF sin bucle debería ser fácilmente reparable. Creo que vale la pena hacerlo, ya que la breve animación que muestra actualmente se ve genial.
trichoplax
47

Homenaje a un clásico

V1 : Inspirado por "Be happy" de DreamWarrior, este envío directo incorpora una pequeña imagen de pixel art en cada canal de color. ¡Ni siquiera tuve que jugar golf el código!
V2 : ahora con un código considerablemente más corto y un borde negro grueso que aísla solo la "pantalla del juego".
V3 : nave espacial, bala, alienígenas dañados y borde azul, ¡ay! Tratando de apuntar a esto , más o menos.

// RED
#define g(I,S,W,M)j/128%8==I&W>>(j/32%4*16+i/64)%M&S[abs(i/4%16-8)-(I%2&i%64<32)]>>j/4%8&1
return g(1,"_\xB6\\\x98\0\0\0",255L<<36,64)?j:0;

// GREEN
#define S g(6,"\xFF\xFE\xF8\xF8\xF8\xF8\xF0\x0",1L<<22,64)|i/4==104&j/24==30
return g(2,"<\xBC\xB6}\30p\0\0",4080,32)|S?j:0;

// BLUE
return g(3,"_7\xB6\xFE\x5E\34\0",0x70000000FD0,64)|S|abs(i/4-128)==80&abs(j/4-128)<96|abs(j/4-128)==96&abs(i/4-128)<80?j:0;

Invasores espaciales


Me topé con una edición de Umber Ferrule cuyo avatar me inspiró a agregar otra entrada basada en pixel art. Dado que la idea central del código es muy similar a la de Space Invaders, la agrego a esta entrada, aunque las dos definitivamente tenían diferentes puntos desafiantes. Para este, obtener el rosa correcto (a expensas del blanco) y el hecho de que es un sprite bastante grande probaron ser buenos desafíos. Los escapes hexadecimales ( \xFFetc.) en el canal rojo representan sus caracteres correspondientes en el archivo fuente (es decir, el canal rojo en el archivo fuente contiene datos binarios), mientras que los escapes octales son literales (es decir, están presentes en el archivo fuente).

// RED
#define g(S)(S[i/29%18*2+j/29/8%2]>>j/29%8&1)*DM1*(abs(i-512)<247&abs(j-464)<232)
return g("\xF3\xF2\xF2\x10\xF4\0\xF2\x10\xE1\xE0\x81\0\x80\0\x80\0\0\0\0\0@\0! \x03d8,=\x2C\x99\x84\xC3\x82\xE1\xE3");

// GREEN
return g(";\376z\34\377\374\372\30k\360\3\200\0\0\0\0\0\0\200\0\300\0\341 \373d\307\354\303\374e\374;\376;\377")? DM1 : BL(i,j)? DM1/2 : 0;

// BLUE
return g("\363\360\362\20\364\0\362\20\341\340\200\0\200\0\200\0\0\0\0\0\0\0\0\0\0\08\0<\0\230\0\300\0\341\340") / 2;

Bub (Bubble Bobble)

Luciérnaga
fuente
3
Me encanta esto. Mucho espacio para agregar características adicionales también ...
trichoplax
1
Sí, hay muchos trucos para reducir el tamaño. Podría intentar extenderlo mañana.
FireFly
Esto es increíblemente corto ahora. ¿Podría ajustar uno de estos patrones de bits en la textura en su respuesta de emisión de rayos ...?
Trichoplax
@ MartinBüttner oops, tienes razón. Lo arreglé e hice otra actualización de las funciones.
FireFly
Genial, me gusta cómo tomaste el arte de 8x8 píxeles y lo "redimensionaste" sobre la marcha. Sin embargo, tuve que hacer algunos cambios y todavía no obtengo exactamente su imagen. Cambié el 1L y 255L a 1LL y 255LL. Como eso lo mejoró, supongo que probablemente esté compilando en modo de 64 bits y hay algunos problemas de ancho de bits que hacen que el resto de mi imagen salga mal. Pero, aun así, ¡buen trabajo!
DreamWarrior
44

Pintura de acción

Quería intentar recrear algo similar al trabajo de Jackson Pollock : gotear y verter pintura sobre un lienzo horizontal. Aunque me gustaron los resultados, el código fue demasiado largo para publicarlo en esta pregunta y mis mejores esfuerzos solo lo redujeron a unos 600 bytes. Entonces, el código publicado aquí (que tiene funciones de 139 bytes, 140 bytes y 140 bytes respectivamente) fue producido con una enorme cantidad de ayuda de algunos de los genios en el chat . Muchas gracias a:

para una implacable sesión de golf grupal.

unsigned char RD(int i,int j){
#define E(q)return i+j?T-((T-BL(i,j))*q):T;
#define T 255
#define R .1*(rand()%11)
#define M(v)(v>0&v<DIM)*int(v)
#define J [j]*250;
E(21)}

unsigned char GR(int i,int j){
#define S DIM][DIM],n=1e3,r,a,s,c,x,y,d=.1,e,f;for(;i+j<1&&n--;x=R*DM1,y=R*DM1,s=R*R*R*R,a=R*7,r=s*T)for(c=R;r>1;x+=s*cos(a),y+=s*sin
E(21)}

unsigned char BL(int i,int j){static float m[S(a),d=rand()%39?d:-d,a+=d*R,s*=1+R/99,r*=.998)for(e=-r;e++<r;)for(f=-r;f++<r;)m[M(x+e)*(e*e+f*f<r)][M(y+f)]=c;return T-m[i]J}

pintura de acción 21, 21

La macro E (q) se usa en las funciones RD y GR. Cambiar el valor del argumento cambia la forma en que cambian los componentes rojo y verde de los colores. La macro J termina con un número que se utiliza para determinar cuánto cambia el componente azul, lo que a su vez afecta a los componentes rojo y verde porque se calculan a partir de él. He incluido algunas imágenes con los argumentos rojo y verde de E variados para mostrar la variedad de combinaciones de colores posibles. Desplácese sobre las imágenes de los valores rojo y verde si desea ejecutarlas usted mismo.

pintura de acción 14, 14

pintura de acción 63, 49

pintura de acción 56, 42

pintura de acción 0, 49

Todas estas imágenes se pueden ver a tamaño completo si las descarga. El tamaño del archivo es pequeño ya que el color plano se adapta al algoritmo de compresión PNG, por lo que no se requirió compresión con pérdida para cargarlo en el sitio.

Si desea ver imágenes de varias etapas en el proceso de golf mientras probamos diferentes cosas, puede mirar en el chat de pintura de acción .

trichoplax
fuente
77
He estado siguiendo esta pregunta y todas las respuestas durante un par de semanas, y tengo que decir que esta es la primera que me dejó con la boca abierta. SANTO INCREÍBLE. Quiero decir, todas las respuestas aquí son geniales, pero esta es algo que nunca hubiera esperado que fuera posible.
Todd Lehman
1
@ToddLehman gracias! Esto ciertamente no es algo de lo que sería capaz solo - Lo sé porque intenté ...
trichoplax
2
¡INCREÍBLE! Uno de los mejores en esta pregunta y para mí el único (tal vez excepto el ganador) que parece dibujado por humanos :)
cyriel
1
@cyriel muchas gracias. Se podría decir que este fue dibujado por 5 humanos ...
trichoplax
43

Pensé que jugaría con los parámetros de este código ... Todo el crédito va a @Manuel Kasten. Estos son tan geniales que no pude resistir publicar. Caliente y frio

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 1000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);

BubbleGumRupture http://i57.tinypic.com/3150eqa.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 40*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 10*pow((n)/800,.5);

SeussZoom http://i59.tinypic.com/am3ypi.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 4000*pow((n)/800,.5);

SeussEternalForest http://i61.tinypic.com/35akv91.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);
Kyle McCormick
fuente
3
A mí me parece el Dr. Seuss. ¡Muy genial!
DLosc
3
Jaja, en realidad nombré los dos archivos inferiores Seuss1 y Sueuss2
Kyle McCormick
42

Editar: Esta es ahora una respuesta válida, gracias a las declaraciones directas de GRy BL.

¡Divirtiéndose con la secuencia Q de Hofstadter! Si usamos la distancia radial desde algún punto como entrada y la salida como color inverso, obtenemos algo que parece vinilo coloreado.

ingrese la descripción de la imagen aquí

La secuencia es muy similar a la secuencia de Fibonacci, pero en lugar de retroceder 1 y 2 pasos en la secuencia, toma los dos valores anteriores para determinar qué tan lejos retroceder antes de tomar la suma. Crece más o menos lineal, pero de vez en cuando hay una explosión de caos (a intervalos crecientes) que luego se establece en una secuencia casi lineal nuevamente antes de la próxima explosión:

ingrese la descripción de la imagen aquí

Puede ver estas ondas en la imagen después de las regiones que se ven muy "planas" en color.

Por supuesto, usar solo un color es aburrido.

ingrese la descripción de la imagen aquí

Ahora para el código. Necesito la función recursiva para calcular la secuencia. Para hacer eso lo uso RDsiempre que jsea ​​negativo. Desafortunadamente, eso no deja suficientes caracteres para calcular el valor del canal rojo en sí, por lo que RDa su vez llama GRcon un desplazamiento para producir el canal rojo.

unsigned short RD(int i,int j){
    static int h[1000];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):GR(i+256,j+512);
}
unsigned short GR(int i,int j){
    return DIM-4*RD(sqrt((i-512)*(i-512)+(j-768)*(j-768))/2.9,-1);
}
unsigned short BL(int i,int j){
    return DIM-4*RD(sqrt((i-768)*(i-768)+(j-256)*(j-256))/2.9,-1);
}

Por supuesto, este es el uso más simple posible de la secuencia, y quedan muchos caracteres. ¡Siéntase libre de pedirlo prestado y hacer otras locuras con él!

Aquí hay otra versión donde el límite y los colores están determinados por la secuencia Q. En este caso, había suficiente espacio RDpara que ni siquiera necesitara la declaración de avance:

unsigned short RD(int i,int j){
    static int h[1024];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):RD(2*RD(i,-1)-i+512>1023-j?i:1023-i,-1)/0.6;
}
unsigned short GR(int i,int j){
    return RD(i, j);
}
unsigned short BL(int i,int j){
    return RD(i, j);
}

ingrese la descripción de la imagen aquí

Martin Ender
fuente
1
¡Esa segunda imagen grisácea es impresionante!
tomsmeding
¿Puede compactar esto lo suficiente como para usar las funciones r / g / b de manera recursiva, con coordenadas no válidas para las llamadas recursivas?
Sparr
Me encantó la imagen multicolor. ¡Buena respuesta!
Alex
41

Esto calcula la transformación de Joukowsky de un conjunto de círculos concéntricos centrados en un punto ligeramente desplazado del origen. Modifiqué ligeramente las intensidades en el canal azul para dar un poco de variación de color.

unsigned short RD(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s,n=hypot(r+(.866-r/2)/q,s+(r*.866+s/2)/q),
    d=.5/log(n);if(d<0||d>1)d=1;return d*(sin(n*10)*511+512);
}
unsigned short GR(int i,int j){
    return 0;
}
unsigned short BL(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s;return RD(i,j)*sqrt(q/40);
}

ingrese la descripción de la imagen aquí

ossifrage aprensivo
fuente
39

C objetivo

Reescribí el código C ++ en Objective-C porque no pude compilarlo ... Dio los mismos resultados que otra respuesta cuando se ejecutaba en mi iPad, así que eso está bien.

Aquí está mi presentación:

Triángulos en abundancia

El código detrás de esto es bastante simple:

unsigned short red_fn(int i,int j)
{
    return j^j-i^i;
}
unsigned short green_fn(int i,int j)
{
    return (i-DIM)^2+(j-DIM)^2;
}
unsigned short blue_fn(int i,int j)
{
    return i^i-j^j;
}

Puede ampliar los cuadrados multiplicando iy jpor 0.5, 0.25etc. antes de que se procesen.

Max Chuquimia
fuente
¿Estás seguro de que es el mismo código que usaste? El ^ parece un poco extraño, porque (i ^ i) siempre es 0 (el XOR), y el ^ 2 parece más un cuadrado que un bit XOR.
Manuel Ferreria
1
@ManuelFerreria Con el XOR, el código en realidad se compila así: x^(x-y)^y(esto también me quitó la primera vez). Si tiene capacidades de iOS, aquí está mi código: gist.github.com/Jugale/28df46f87037d81d2a8f
Max Chuquimia
38

Salpicadura de pintura de Sierpinski

Quería jugar más con los colores, así que seguí cambiando mi otra respuesta (la swirly) y finalmente terminé con esto.

Salpicadura de pintura de Sierpinski

unsigned short RD(int i,int j){
    return(sqrt(_sq(abs(73.-i))+_sq(abs(609.-j)))+1.)/abs(sin((sqrt(_sq(abs(860.-i))+_sq(abs(162.-j))))/115.)+2)/(115^i&j);
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(abs(160.-i))+_sq(abs(60.-j)))+1.)/abs(sin((sqrt(_sq(abs(73.-i))+_sq(abs(609.-j))))/115.)+2)/(115^i&j);
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(abs(600.-i))+_sq(abs(259.-j)))+1.)/abs(sin((sqrt(_sq(abs(250.-i))+_sq(abs(20.-j))))/115.)+2)/(115^i&j);
}

Es mi avatar ahora. :PAGS

cjfaure
fuente
44
Buen trabajo. señor, buen trabajo.
EaterOfCode
37

Me siento obligado a enviar esta entrada que llamaré "comportamiento indefinido", que ilustrará lo que hace su compilador con funciones que se supone que devuelven un valor pero no:

unsigned short red_fn(int i,int j){}
unsigned short green_fn(int i,int j){}
unsigned short blue_fn(int i,int j){}

Todos los píxeles negros:

todos los píxeles negros

Píxeles seudoaleatorios:

píxeles seudoaleatorios

Y, por supuesto, una gran cantidad de otros posibles resultados dependiendo de su compilador, computadora, administrador de memoria, etc.

Sparr
fuente
3
¿Cuál conseguiste?
tomsmeding
3
Obtuve negro sólido y color sólido que cambiaron entre diferentes ejecuciones del programa, con diferentes compiladores.
Sparr
8
Mi compilador solo comete errores y me grita por no devolver un valor.
Pharap
3
@Pharap eso no es malo :)
Sparr
Dudo que alguna vez obtengas una aleatoriedad tan agradable como sugiere tu segunda imagen. Es mucho más probable un valor constante, el índice del bucle, etc. (lo que sea que esté almacenado dentro de EAX cuando se llama a la función).
ejemplo
37

maravilloso

groovy.png

Solo algunos trigonometría y extraños trucos macro.

RD:

#define I (i-512)
#define J (j-512)
#define A (sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

GRAMO:

#undef A
#define A (M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

LICENCIADO EN DERECHO:

#undef A
#define A (2*M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

EDITAR: si M_PIno está permitido debido a que solo está presente en los sistemas compatibles con POSIX, se puede reemplazar con el literal 3.14.

Fraxtil
fuente
1
Si tienes caracteres de repuesto, acos(-1)es un buen reemplazo para M_PI.
Martin Ender
33

No soy bueno en matemáticas. Siempre fui un estudiante pobre en la clase de matemáticas. Así que hice uno simple.

mathpic1.png

Usé el código Javascript modificado de user1455003 . Y este es mi código completo .

function red(x, y) {
    return (x + y) & y;
}

function green(x, y) {
    return (255 + x - y) & x;
}

function blue(x, y) {
    // looks like blue channel is useless
    return Math.pow(x, y) & y;
}

Es muy corto, por lo que las tres funciones encajan en un solo tweet.


mathpic2.png

function red(x, y) {
    return Math.cos(x & y) << 16;
}

function green(x, y) {
    return red(DIM - x, DIM - y);
}

function blue(x, y) {
    return Math.tan(x ^ y) << 8;
}

Otras funciones muy cortas. Encontré este patrón sierpinski (y algún patrón tangente) mientras jugaba con varias funciones matemáticas. Este es el código completo

Bocadillo
fuente
Solo i&jrepresenta el triángulo de Sierpinski en realidad. Lo cual es asombroso .
cjfaure
Ese último es digno de una foto de perfil.
mbomb007
32

JavaScript

var can = document.createElement('canvas');
can.width=1024;
can.height=1024;
can.style.position='fixed';
can.style.left='0px';
can.style.top='0px';
can.onclick=function(){
  document.body.removeChild(can);
};

document.body.appendChild(can);

var ctx = can.getContext('2d');
var imageData = ctx.getImageData(0,0,1024,1024);
var data = imageData.data;
var x = 0, y = 0;
for (var i = 0, len = data.length; i < len;) {
    data[i++] = red(x, y) >> 2;
    data[i++] = green(x, y) >> 2;
    data[i++] = blue(x, y) >> 2;
    data[i++] = 255;
    if (++x === 1024) x=0, y++;
}
ctx.putImageData(imageData,0,0);

function red(x,y){
if(x>600||y>560) return 1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function green(x,y){
if(x>600||y>560) return y%160<80?0:1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:1024;
}

Estados Unidos

Otra version. Los cuerpos funcionales son tuiteables.

function red(x,y){
c=x*y%1024
if(x>600||y>560) return c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function green(x,y){
c=x*y%1024
if(x>600||y>560) return y%160<80?0:c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:x*y%1024;
}

ingrese la descripción de la imagen aquí

Función de renderizado de imagen revisada. draw (rgbFunctions, setCloseEvent);

function draw(F,e){
    var D=document
    var c,id,d,x,y,i,L,s=1024,b=D.getElementsByTagName('body')[0]
    c=D.createElement('canvas').getContext('2d')
    if(e)c.canvas.onclick=function(){b.removeChild(c.canvas)}
    b.appendChild(c.canvas)
    c.canvas.width=c.canvas.height=s
    G=c.getImageData(0,0,s,s)
    d=G.data
    x=y=i=0;
    for (L=d.length;i<L;){
        d[i++]=F.r(x,y)>>2
        d[i++]=F.g(x,y)>>2
        d[i++]=F.b(x,y)>>2
        d[i++]=255;
        if(++x===s)x=0,y++
    }
    c.putImageData(G,0,0)
}

Púrpura

var purple = {
    r: function(i,j) {
        if (j < 512) j=1024-j
        return (i % j) | i
    },
    g: function(i,j){
        if (j < 512) j = 1024 -j
        return (1024-i ^ (i %j)) % j
    },
    b: function(i,j){
        if (j < 512) j = 1024 -j
        return 1024-i | i+j %512
    }
};

draw(purple,true);

ingrese la descripción de la imagen aquí

martillo de lobo
fuente
CHEATER! CHEATER! ; D (es una respuesta válida, demasiado inteligente: P ¡Buena!)
tomsmeding
1
Jaja ... sí, lo sé, así que presenté uno que está más en el espíritu de la pregunta. En realidad intenté hacer patrones y pensé que me preguntaría si realmente podría dibujar algo.
Wolfhammer
Puede hacer que las imágenes en color poco profundo se vean un poco más ricas agregando algo de ruido de grano de película en los bits inferiores aplicando un "| Math.random () * 256" al final de ellas. Hace que los tonos más oscuros se perturben más al azar sin alterar los reflejos. (y aumentar el número según el umbral de oscuridad)
Kent Fredric
aleatoriedad rgb @ [10,728,728] i.imgur.com/ms4Cuzo.png
Kent Fredric
31

Pintor planetario

//red
static int r[DIM];int p=rand()%9-4;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//green
static int r[DIM];int p=rand()%7-3;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//blue
static int r[DIM];int p=rand()%15-7;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;

Inspirado por la entrada obviamente impresionante de Martin , esta es una versión diferente. En lugar de sembrar aleatoriamente una parte de los píxeles, comienzo con la esquina superior izquierda como RGB (512,512,512), y tomo caminatas aleatorias en cada color desde allí. El resultado parece algo de un telescopio (imo).

Cada píxel toma el promedio de los píxeles arriba / a la izquierda y agrega un poco al azar. Puedes jugar con la variabilidad cambiando la pvariable, pero creo que lo que estoy usando es un buen equilibrio (principalmente porque me gusta el azul, por lo que una mayor volatilidad de desenfoque da buenos resultados).

Hay un ligero sesgo negativo de la división de enteros al promediar. Sin embargo, creo que funciona y le da un bonito efecto de oscurecimiento a la esquina inferior.

Por supuesto, para obtener más que un solo resultado, deberá agregar una srand()línea a su función principal.

bandas

Geobits
fuente
2
Si la imagen fuera un poco más grande, se vería como rayos de luz. o:
cjfaure
1
@cjfaure si ve la imagen a tamaño completo (descargar / hacer clic derecho y ver la imagen / lo que sea que funcione en su sistema) entonces se ve aún más hermosa con los detalles adicionales.
trichoplax
¡hazlo un círculo rodeado de negro, y eso lo convertirá en un planeta!
Khaled.K
1
Intenté envolver esto alrededor de una esfera en la licuadora, y rendericé una animación. Ver ti aquí: gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs
30

Olas reflejadas

unsigned char RD(int i,int j){
#define A static double w=8000,l,k,r,d,p,q,a,b,x,y;x=i;y=j;for(a=8;a+9;a--){for(b=8;b+9;b--){l=i-a*DIM-(int(a)%2?227:796);
return 0;}

unsigned char GR(int i,int j){
#define B k=j-b*DIM-(int(b)%2?417:606);r=sqrt(l*l+k*k);d=16*cos((r-w)/7)*exp(-_sq(r-w)/120);p=d*l/r;q=d*k/r;x-=p;y-=q;}}
return 0;}

unsigned char BL(int i,int j){AB
return (int(x/64)+int(y/64))%2*255;}

Un patrón básico de tablero de ajedrez distorsionado de acuerdo con la posición de una ola que se expande desde un punto como una piedra caída en un estanque (¡muy lejos de ser físicamente exacto!). La variable wes el número de píxeles desde ese punto que la onda se ha movido. Si wes lo suficientemente grande, la onda se refleja desde los lados de la imagen.

w = 225

ondas con w = 225

w = 360

ondas con w = 360

w = 5390

ondas con w = 5390

Aquí hay un GIF que muestra una sucesión de imágenes a medida que la ola se expande. He proporcionado varios tamaños diferentes, cada uno de los cuales muestra tantos fotogramas como lo permita el límite de tamaño de archivo de 500 KB.

ondas grandes GIF

ondas pequeñas GIF ondas medianas GIF


Si puedo encontrar una manera de encajar, idealmente quisiera modelar la interferencia de las olas para que las olas se vean más realistas cuando se crucen. Sin embargo, estoy satisfecho con la reflexión.

Tenga en cuenta que realmente no he modelado la reflexión de onda en 3 lotes de 140 bytes. Realmente no hay ningún reflejo, simplemente parece que es así. He escondido la explicación en caso de que alguien quiera adivinar primero:

La primera onda reflejada es idéntica a una onda que se origina desde el otro lado del borde de la imagen, a la misma distancia que el punto original. Entonces, el código calcula la posición correcta para los 4 puntos necesarios para dar el efecto de reflexión desde cada uno de los 4 bordes. Los niveles adicionales de onda reflejada son todos idénticos a una onda que se origina en un mosaico más alejado, si imagina la imagen como un mosaico en un plano. El código da la ilusión de 8 niveles de reflexión al mostrar 189 círculos de expansión separados, cada uno colocado en el punto correcto en una cuadrícula de 17 por 17, para que pasen por el cuadrado central de la cuadrícula (es decir, el cuadrado de la imagen) en los momentos adecuados para dar la impresión del nivel de reflexión actual requerido. Esto es simple (¡y corto!) Para codificar, pero se ejecuta muy lentamente ...

trichoplax
fuente
3
Me encantan los GIF y la explicación.
DLosc
Neato! Pero hombre, entradas como estas me hacen pensar que necesito una computadora más rápida (o más paciencia, jajaja). O su computadora es mucho más rápida, o no quiero pensar cuánto tiempo le tomó generar todos esos marcos GIF.
DreamWarrior
3
@DreamWarrior No soy yo el que es paciente. Es mi ordenador portátil que no le importa funcionando durante la noche mientras duermo ...
Trichoplax
2
Veo a Pacman en la segunda imagen.
AL