A matemática inteira pode gerar padrões surpreendentes quando dispostos em uma grade. Mesmo as funções mais básicas podem produzir designs incrivelmente elaborados!

Seu desafio

Escreva 3 corpos de função Tweetable (significando 140 caracteres ou menos) para os valores de vermelho, verde e azul para uma imagem de 1024x1024.

A entrada para as funções será dois números inteiros i (número da coluna para o pixel especificado) ej (número da linha para o pixel especificado) e a saída será um curto não assinado entre 0 e 1023, inclusive, o que representa a quantidade do valor especificado cor presente no pixel (i, j).

Por exemplo, as três funções a seguir produzem a imagem abaixo:

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

/* 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;

As regras

• Dado esse código C ++ , substitua em suas funções. Forneci algumas macros e incluí a biblioteca, e você pode incluir complex.h. Você pode usar quaisquer funções dessas bibliotecas e / ou minhas macros. Por favor, não use nenhum recurso externo além disso.

• Se essa versão não estiver funcionando para você, verifique se está compilando com:

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

  Se isso não funcionar, use a versão alternativa usando caracteres não assinados em vez de curtos não assinados.

Michaelangelo forneceu uma versão de saída em cores de 24 ou 48 bits limpa .

• Você pode implementar sua própria versão em outro idioma, mas deve se comportar da mesma maneira que a versão C ++ fornecida e apenas funções dos recursos internos do C ++, da biblioteca ou das macros fornecidas podem ser usadas para torná-la justa.
• Poste apenas seus três corpos funcionais - não inclua meu código na sua postagem
• Inclua uma versão menor ou uma cópia incorporada da sua imagem. Eles são criados em um formato ppm e podem precisar ser convertidos em outro para uma visualização adequada no stackexchange.
• Os corpos das funções (sem incluir a assinatura) devem ter 140 caracteres ou menos.
• Este é um concurso de popularidade - a maioria dos votos vence

Mandelbrot 3 x 133 caracteres

A primeira coisa que me veio à mente foi "Mandelbrot!".

Sim, eu sei que já existe um envio de mandelbrot. Depois de confirmar que consigo obtê-lo abaixo de 140 caracteres, levei os truques e otimizações dessa solução para a minha (obrigado Martin e Todd). Isso deixou espaço para escolher um local e um zoom interessantes, além de um bom tema de cores:

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 no total

Tentei reduzi-lo a 140 para todos os 3 canais. Há um pouco de ruído colorido próximo à borda, e a localização não é tão interessante quanto a primeira, mas: 132 caracteres

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

Toalhas de mesa

Plano

Comecei colocando um padrão xadrez / guingão em perspectiva como uma toalha de mesa sem limites:

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

Ondulação

Introduzi uma ondulação (perspectiva não estritamente correta, mas ainda com 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;
}

Cor

Depois, fiz algumas cores mais granuladas para dar detalhes em uma escala maior de escalas e para tornar a imagem mais 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;
}

Em movimento

Reduzir um pouco mais o código permite definir uma fase de onda P com 2 casas decimais, o que é suficiente para quadros próximos o suficiente para uma animação suave. Reduzi a amplitude nesta fase para evitar induzir a doença do mar e mudei a imagem inteira para mais 151 pixels (ao custo de 1 caractere extra) para empurrar o aliasing para o topo da imagem. O aliasing animado é 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;}

Pintor aleatório

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

Aqui está uma entrada baseada em aleatoriedade. Para cerca de 0,1% dos pixels, escolhe uma cor aleatória, para os outros usa a mesma cor que um pixel adjacente aleatório. Observe que cada cor faz isso de forma independente; portanto, isso é apenas uma sobreposição de uma imagem aleatória em verde, azul e vermelho. Para obter resultados diferentes em diferentes execuções, você precisará adicionar srand(time(NULL))à mainfunção.

Agora, para algumas variações.

Ao pular pixels, podemos torná-lo um pouco mais embaçado.

E então podemos mudar lentamente as cores, onde os transbordamentos resultam em mudanças bruscas que tornam isso mais parecido com pinceladas

Coisas que eu preciso descobrir:

• Por alguma razão, não posso colocar srandessas funções sem obter um segfault.
• Se eu pudesse fazer os passeios aleatórios da mesma forma nas três cores, pode parecer um pouco mais ordenado.

Você também pode tornar a caminhada aleatória 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];

dar a voce

Pinturas mais aleatórias

Eu brinquei com isso um pouco mais e criei algumas outras pinturas aleatórias. Nem tudo isso é possível dentro das limitações deste desafio, por isso não quero incluí-las aqui. Mas você pode vê-los nesta galeria imgur, juntamente com algumas descrições de como eu os produzi.

Estou tentado a desenvolver todas essas possibilidades em um framework e colocá-lo no GitHub. (Ainda não existem coisas como essa, mas é divertido de qualquer maneira!)

Algumas coisas swirly pontudas

Sim, eu sabia exatamente como nomear.

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

EDIT: não usa mais pow. EDIT 2: @PhiNotPi apontou que não preciso usar tanto o abdômen.

Você pode alterar os pontos de referência com bastante facilidade para obter uma imagem diferente:

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 apontou que minhas fotos têm Batman nelas.

Claro, tem que haver uma submissão de Mandelbrot.

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

Tentando melhorar o esquema de cores agora. É trapaça se eu definir o cálculo como uma macro red_fne usá-la nas outras duas para ter mais caracteres para a seleção de cores sofisticadas em verde e azul?

Edit: É realmente difícil criar esquemas de cores decentes com esses poucos bytes restantes. Aqui está outra versão:

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

E de acordo com a sugestão de githubphagocyte e com as melhorias de Todd Lehman, podemos facilmente escolher seções menores:

Por exemplo

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

dá

Conjuntos de Julia

Se houver um Mandelbrot, também deve haver um conjunto de Julia.

Você pode passar horas ajustando os parâmetros e funções, portanto, este é apenas um rápido, que parece decente.

Inspirado pela participação 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;}

Gostaria de um pouco de RNG?

OK, o comentário de Sparr me colocou na pista para escolher aleatoriamente os parâmetros dessas pequenas Julias. Eu tentei primeiro fazer hackers em nível de bit com o resultado detime(0) mas o C ++ não permite literais de ponto flutuante hexadecimal, então esse era um beco sem saída (com meu conhecimento limitado pelo menos). Eu poderia ter usado um elenco pesado para consegui-lo, mas isso não se encaixaria nos 140 bytes.

Eu não tinha muito espaço de qualquer maneira, então tive que largar a Julia vermelha para colocar minhas macros e ter um RNG mais convencional ( timed seed e real rand(), woohoo!).

Opa, algo está faltando. Obviamente, esses parâmetros precisam ser estáticos ou você terá alguns resultados estranhos (mas engraçado, talvez eu investigue um pouco mais tarde se encontrar algo interessante).

Então aqui estamos, apenas com canais verde e azul:

Agora vamos adicionar um padrão vermelho simples para preencher o vazio. Não é realmente imaginativo, mas eu não sou um programador gráfico ... ainda :-)

E, finalmente, o novo código com parâmetros aleatórios:

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

Ainda resta espaço agora ...

Este é interessante porque não usa os parâmetros i, j. Em vez disso, ele se lembra do estado em uma variável 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;
}

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

Buddhabrot (+ Antibuddhabrot)

Edit: É um Buddhabrot adequado agora!

Edit: Consegui limitar a intensidade da cor dentro do limite de bytes, para que não haja mais pixels falsamente pretos devido ao estouro.

Eu realmente queria parar depois das quatro ... mas ...

Isso fica um pouco compactado durante o upload (e diminui ao incorporar); portanto, se você quiser admirar todos os detalhes, aqui está o interessante corte de 512 x 512 (que não é compactado e é exibido em tamanho real):

Obrigado ao githubphagocyte pela ideia. Isso exigiu um abuso bastante complicado das três funções de cores:

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

Restam alguns bytes para um melhor esquema de cores, mas até agora não encontrei nada que superasse a imagem em escala de cinza.

O código fornecido usa pontos iniciais de 4096 x 4096 e faz até 500.000 iterações em cada uma delas para determinar se as trajetórias escapam ou não. Isso levou entre 6 e 7 horas na minha máquina. Você pode obter resultados decentes com uma grade de 2k por 2k e iterações de 10k, o que leva dois minutos, e até mesmo uma grade de 1k por 1k com iterações de 1k parece bastante agradável (isso leva 3 segundos). Se você quiser mexer com esses parâmetros, há alguns lugares que precisam ser alterados:

• Para alterar a profundidade da recursão do Mandelbrot, ajuste as duas instâncias de 5e5in BLna sua contagem de iterações.
• Para alterar a resolução da grade, alterar todos os quatro 4096em RDque a resolução desejada e 1024.em GRpelo mesmo fator para manter a escala correta.
• Provavelmente, você também precisará dimensionar a entrada return c[i][j], GRpois ela contém apenas o número absoluto de visitas de cada pixel. A cor máxima parece ser principalmente independente da contagem de iterações e é dimensionada linearmente com o número total de pontos de partida. Portanto, se você deseja usar uma grade de 1k por 1k, talvez queira return c[i][j]*16;ou algo parecido, mas esse fator às vezes precisa de alguma brincadeira.

Para aqueles que não estão familiarizados com o Buddhabrot (como eu há alguns dias), é baseado no cálculo de Mandelbrot, mas a intensidade de cada pixel é a frequência com que esse pixel foi visitado nas iterações das trajetórias de fuga. Se contamos as visitas durante trajetórias sem escape, é um Antibuddhabrot. Existe uma versão ainda mais sofisticada chamada Nebulabrot, na qual você usa uma profundidade de recursão diferente para cada canal de cor. Mas vou deixar isso para outra pessoa. Para mais informações, como sempre, Wikipedia .

Originalmente, não fazia distinção entre trajetórias de escape e não-escape. Isso gerou uma trama que é a união de um Buddhabrot e um Antibuddhabrot (como apontado pelos gitubagócitos).

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

Este parece um pouco com uma fotografia desbotada ... eu gosto disso.

Pentágono de Sierpinski

Você pode ter visto o método do jogo do caos de aproximar o triângulo de Sierpinski plotando pontos a meio caminho de um vértice escolhido aleatoriamente. Aqui eu segui a mesma abordagem usando 5 vértices. O código mais curto que eu pude escolher incluiu a codificação embutida dos 5 vértices, e não havia como encaixar tudo isso em 140 caracteres. Por isso, delegamos o componente vermelho a um pano de fundo simples e usei o espaço livre na função vermelho para definir uma macro para colocar as outras duas funções abaixo de 140 também. Então, tudo é válido ao custo de não ter componente vermelho no 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];}

Agradecemos a Martin Büttner pela idéia mencionada nos comentários da pergunta sobre como definir uma macro em uma função para usar em outra e também por usar a memoisation para preencher os pixels em uma ordem arbitrária, em vez de restringir-se à ordem raster da função principal .

A imagem tem mais de 500 KB e é convertida automaticamente em jpg por troca de pilhas. Isso obscurece alguns dos detalhes mais delicados, então também incluí o quarto superior direito como um png para mostrar a aparência original:

Partitura

Música Sierpinski. : D Os caras no bate-papo dizem que parece mais o papel perfurado para caixas de música.

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

Alguns detalhes de como isso funciona ... na verdade, é apenas um zoom na renderização de alguns triângulos ondulados de Sierpinski. A aparência da partitura (e também do bloqueio) é o resultado do truncamento inteiro. Se eu mudar a função vermelha para, digamos,

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

o truncamento é removido e obtemos a renderização em resolução total:

Então, sim, isso é interessante.

Gerador de diagrama aleatório Voronoi alguém?

OK, este me deu um tempo difícil. Eu acho que é muito bom, mesmo que os resultados não sejam tão artísticos quanto alguns outros. Esse é o problema da aleatoriedade. Talvez algumas imagens intermediárias pareçam melhores, mas eu realmente queria ter um algoritmo totalmente funcional com diagramas de voronoi.

Editar:

Este é um exemplo do algoritmo final. A imagem é basicamente a superposição de três diagramas voronoi, um para cada componente de cor (vermelho, verde, azul).

Código

versão comentada e não-gasta no 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];
}

Foram necessários muitos esforços, então sinto vontade de compartilhar os resultados em diferentes estágios, e há bons (incorretos) para mostrar.

Primeiro passo: coloque alguns pontos aleatoriamente, com x=y

Eu o convertei para jpeg porque o png original era muito pesado para upload ( >2MB), aposto que são mais de 50 tons de cinza!

Segundo: tenha uma melhor coordenada y

Eu não podia me dar ao luxo de ter outra tabela de coordenadas gerada aleatoriamente para o yeixo, então eu precisava de uma maneira simples de obter as " aleatórias " no menor número de caracteres possível. Eu fui usar a xcoordenada de outro ponto na tabela, fazendo um bit ANDde bit no índice do ponto.

3º: não me lembro, mas está ficando bom

Mas, naquele momento, eu tinha mais de 140 caracteres, então precisava jogar bastante.

4º: scanlines

Brincadeirinha, isso não é desejado, mas meio legal, acho.

Ainda trabalhando na redução do tamanho do algoritmo, tenho orgulho de apresentar:

Edição StarFox

Voronoi instagram

5º: aumentar o número de pontos

Agora tenho um código de trabalho, então vamos de 25 para 60 pontos.

É difícil ver apenas uma imagem, mas os pontos estão quase todos localizados no mesmo yintervalo. Claro, não mudei a operação bit a bit, &42é muito melhor:

E aqui estamos, no mesmo ponto da primeira imagem deste post. Vamos agora explicar o código para os raros que estariam interessados.

Código explicado e não jogado

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

Obrigado pela leitura até agora.

O Fractal Lyapunov

A string usada para gerar isso foi AABAB e o espaço do parâmetro foi [2,4] x [2,4]. ( explicação da string e do espaço dos parâmetros aqui )

Com espaço limitado no código, achei essa cor bem legal.

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

Também fiz uma variação do conjunto de Mandelbrot. Ele usa um mapa semelhante ao mapa definido de Mandelbrot. Digamos que M (x, y) é o mapa de Mandelbrot. Então M (sin (x), cos (y)) é o mapa que eu uso e, em vez de verificar os valores de escape, eu uso x, y, pois eles sempre são limitados.

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

EDITAR

Depois de muita dor, finalmente consegui criar um gif da segunda imagem se transformando. Aqui está:

Porque unicórnios.

Não consegui obter a versão dos OPs unsigned shorte os valores de cores até 1023 funcionando; portanto, até que isso seja corrigido, aqui está uma versão usando charo valor máximo de cores 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);
}

Logistic Hills

As funções

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

Ungolfed

Todos os #defines devem caber no BL com menos de 140 caracteres. Aqui está a versão não destruída do algoritmo azul, ligeiramente 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
            }
        }            
    }    
}

Onde os valores de x caem com mais frequência para um dado r (valor de j), o gráfico se torna mais claro (geralmente representado como mais escuro).

Agregação limitada por difusão

Eu sempre fui fascinado pela agregação limitada por difusão e pelo número de maneiras diferentes em que ela aparece no mundo real.

Achei difícil escrever isso em apenas 140 caracteres por função, então tive que tornar o código horrível (ou bonito, se você gosta de coisas como ++d%=4e for(n=1;n;n++)). As três funções de cores se chamam e definem macros para o outro usar, para que não sejam bem-interpretadas, mas cada função tem pouco 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];}

Para visualizar como as partículas se agregam gradualmente, produzi instantâneos em intervalos regulares. Cada quadro foi produzido substituindo o 1 in for(n=1;n;n++)por 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Isso o manteve abaixo do limite de 140 caracteres para cada execução.

Você pode ver que os agregados que crescem próximos um do outro privam um ao outro as partículas e crescem mais lentamente.

Ao fazer uma pequena alteração no código, é possível ver as partículas restantes que ainda não foram anexadas aos agregados. Isso mostra as regiões mais densas onde o crescimento ocorrerá mais rapidamente e as regiões muito esparsas entre os agregados, onde não há mais crescimento devido ao desgaste de todas as partículas.

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

Isso pode ser animado da mesma maneira que antes:

Espiral (140 exatamente)

São 140 caracteres exatamente se você não incluir os cabeçalhos e colchetes das funções. É tanta complexidade em espiral que eu poderia caber no limite 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í uma espiral simples, adicionando padrões às bordas espirais e experimentando como diferentes espirais podem ser combinadas para parecerem legais. Aqui está uma versão não-gasta com comentários explicando o que cada peça faz. Mexer com os parâmetros pode produzir alguns resultados interessantes.

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

Brincando com parâmetros:

Aqui, as espirais estão alinhadas, mas têm padrões de borda diferentes. Em vez das arestas em blocos no exemplo principal, possui arestas inteiramente compostas por ondas de pecado.

Aqui, o gradiente foi removido:

Uma animação ( que por algum motivo não parece estar em loop após o upload, desculpe. Além disso, eu tive que reduzi-la. Basta abri-la em uma nova guia se você perdeu a animação ):

E aqui está o álbum imgur com todas as imagens. Eu adoraria ver se alguém pode encontrar outros padrões espirais legais. Além disso, devo dizer, este é de longe um dos maiores desafios por aqui que eu já vi. Desfrutar!

EDIT: Aqui estão alguns fundos feitos a partir dessas espirais com parâmetros alterados.

Além disso, combinando meus padrões de borda em espiral com alguns dos fractais que vi aqui através do uso de xor / e / ou operações, aqui está uma espiral final:

Homenagem a um clássico

V1 : Inspirado no "Seja feliz" da DreamWarrior, esse envio direto incorpora uma pequena imagem de pixel-art em cada canal de cores. Eu nem precisava jogar o código!
V2 : agora com código consideravelmente mais curto e uma borda preta grossa isolando apenas a "tela do jogo".
V3 : nave espacial, bala, alienígenas danificados e borda azul, oh meu! Tentando apontar para isso , aproximadamente.

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

Por acaso, deparei com uma edição de Umber Ferrule, cujo avatar me inspirou a adicionar outra entrada baseada em pixel art. Como a idéia central do código é bastante semelhante à do Space Invaders, anexo-a a esta entrada, embora os dois definitivamente tenham pontos de desafio diferentes. Para este, ficar bem rosa (às custas do branco) e o fato de ser um sprite bastante grande foram bons desafios. Os escapes hexadecimais ( \xFFetc) no canal vermelho representam seus caracteres correspondentes no arquivo de origem (ou seja, o canal vermelho no arquivo de origem contém dados binários), enquanto os escapes octais são literais (ou seja, presentes no arquivo de origem).

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

Pintura de ação

Eu queria tentar recriar algo semelhante ao trabalho de Jackson Pollock - pingando e derramando tinta sobre uma tela horizontal. Embora eu tenha gostado dos resultados, o código foi muito longo para ser postado nesta pergunta e meus melhores esforços ainda o reduziram a cerca de 600 bytes. Portanto, o código postado aqui (que possui funções de 139 bytes, 140 bytes e 140 bytes, respectivamente) foi produzido com uma enorme quantidade de ajuda de alguns dos gênios no bate-papo . Muito obrigado a:

• Eric Tressler
• FireFly
• PhiNotPi
• Martin Büttner

para uma sessão de golfe em grupo implacável.

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}

A macro E (q) é usada nas funções RD e GR. Alterar o valor do argumento altera a maneira como os componentes vermelho e verde das cores mudam. A macro J termina com um número usado para determinar quanto o componente azul é alterado, o que afeta os componentes vermelho e verde porque são calculados a partir dele. Incluí algumas imagens com os argumentos vermelho e verde de E variados para mostrar a variedade possível de combinações de cores. Passe o mouse sobre as imagens para obter os valores vermelho e verde, se você quiser executá-las.

Todas essas imagens podem ser visualizadas em tamanho real se você as baixar. O tamanho do arquivo é pequeno, pois a cor plana se adapta ao algoritmo de compactação PNG, portanto, nenhuma compactação com perdas foi necessária para fazer o upload para o site.

Se você quiser ver imagens de vários estágios do processo de golfe, como tentamos coisas diferentes, consulte o bate-papo sobre pintura de ação .

Achei que eu iria brincar com os parâmetros desse código ... Todo o crédito é para @Manuel Kasten. São tão legais que eu não pude resistir a postar.

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

Edit: Esta é agora uma resposta válida, graças às declarações avançadas de GRe BL.

Divertir-se com a sequência Q de Hofstadter! Se estivermos usando a distância radial de algum ponto como entrada e saída como cor inversa, obteremos algo parecido com vinil colorido.

A sequência é muito semelhante à sequência de Fibonacci, mas, em vez de recuar 1 e 2 etapas na sequência, você toma os dois valores anteriores para determinar a que distância voltar antes de obter a soma. Ela cresce aproximadamente linear, mas de vez em quando há uma explosão de caos (em intervalos crescentes) que então se estabelece em uma sequência quase linear novamente antes da próxima explosão:

Você pode ver essas ondulações na imagem depois de regiões com uma aparência muito "plana".

Obviamente, usar apenas uma cor é chato.

Agora para o código. Eu preciso da função recursiva para calcular a sequência. Para fazer isso, eu uso RDsempre que jé negativo. Infelizmente, isso não deixa caracteres suficientes para calcular o valor do canal vermelho, então, por RDsua vez, chama GRcom um deslocamento para produzir o canal vermelho.

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

Obviamente, esse é o uso mais simples possível da sequência, e há muitos caracteres restantes. Sinta-se livre para emprestá-lo e fazer outras coisas loucas com ele!

Aqui está outra versão em que o limite e as cores são determinados pela sequência Q. Nesse caso, havia espaço suficiente RDpara que eu nem precisasse da declaração de encaminhamento:

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

Isso calcula a transformação de Joukowsky de um conjunto de círculos concêntricos centralizados em um ponto ligeiramente deslocado da origem. Modifiquei levemente as intensidades no canal azul para dar um pouco de variação de cor.

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

Objetivo-C

Reescrevi o código C ++ no Objective-C porque não consegui compilar ... Ele deu os mesmos resultados que outras respostas ao executar no meu iPad, então está tudo bem.

Aqui está o meu envio:

O código por trás disso é bastante simples:

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

Você pode aplicar zoom em praças multiplicando ie jpor 0.5, 0.25etc. antes de serem processadas.

Sierpinski Paint Splash

Eu queria brincar mais com as cores, então continuei mudando minha outra resposta (a swirly) e acabei acabando com isso.

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

É o meu avatar agora. : P

Sinto-me compelido a enviar esta entrada que chamarei de "comportamento indefinido", que ilustrará o que seu compilador faz com funções que deveriam retornar um valor, mas não:

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 os pixels pretos:

Pixels pseudo-aleatórios:

E, é claro, uma série de outros resultados possíveis, dependendo do seu compilador, computador, gerenciador de memória, etc.

groovy

Apenas alguns truques de trigonometria e macro estranhos.

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;

GR:

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

BL:

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

EDIT: se M_PInão for permitido por estar presente apenas em sistemas compatíveis com POSIX, ele poderá ser substituído pelo literal 3.14.

Eu não sou bom em matemática. Eu sempre fui pobre aluno na aula de matemática. Então eu fiz um simples.

Eu usei o código Javascript do user1455003 modificado . E este é o meu 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;
}

É muito curto, então todas as três funções se encaixam em um tweet.

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

Outras funções muito curtas. Encontrei esse padrão de sierpinski (e algum padrão tangente) enquanto brincava com várias funções matemáticas. Este é o código completo

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

Outra versão. os corpos das funções são twittáveis.

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

Função de renderização de imagem 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)
}

Roxa

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

Pintor Planetário

//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 pela entrada obviamente impressionante de Martin , essa é uma opinião diferente. Em vez de semear aleatoriamente uma parte dos pixels, começo com o canto superior esquerdo como RGB (512.512.512) e faço caminhadas aleatórias em cada cor a partir daí. O resultado parece algo de um telescópio (imo).

Cada pixel obtém a média dos pixels acima / à esquerda e adiciona um pouco de aleatoriamente. Você pode brincar com a variabilidade alterando a pvariável, mas acho que estou usando um bom equilíbrio (principalmente porque gosto de azul, então mais volatilidade de desfoque dá bons resultados).

Há uma leve tendência negativa da divisão inteira ao calcular a média. Mas acho que dá certo e dá um bom efeito de escurecimento no canto inferior.

Obviamente, para obter mais do que apenas um resultado, você precisará adicionar uma srand()linha à sua função principal.

Ondas refletidas

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

Um padrão básico do tabuleiro de xadrez distorce de acordo com a posição de uma onda se expandindo de um ponto como uma pedra jogada em um lago (muito longe de ser fisicamente precisa!). A variável wé o número de pixels a partir desse ponto em que a onda se moveu. Se wfor grande o suficiente, a onda será refletida pelos lados da imagem.

w = 225

w = 360

w = 5390

Aqui está um GIF mostrando uma sucessão de imagens à medida que a onda se expande. Forneci vários tamanhos diferentes, cada um mostrando quantos quadros o limite de tamanho do arquivo de 500 KB permitirá.

Se eu conseguir encontrar uma maneira de ajustá-lo, eu gostaria idealmente de modelar a interferência das ondas, para que as ondas pareçam mais realistas quando se cruzam. Estou satisfeito com a reflexão.

Observe que eu realmente não modelei a reflexão da onda em 3 lotes de 140 bytes. Não há realmente nenhuma reflexão acontecendo, apenas parece com isso. Escondi a explicação caso alguém queira adivinhar primeiro:

A primeira onda refletida é idêntica a uma onda originária do outro lado da borda da imagem, à mesma distância do ponto original. Portanto, o código calcula a posição correta para os 4 pontos necessários para fornecer o efeito de reflexão de cada uma das 4 arestas. Níveis adicionais de onda refletida são todos idênticos a uma onda originada em um bloco mais distante, se você imaginar a imagem como um bloco em um plano. O código fornece a ilusão de 8 níveis de reflexão, exibindo 189 círculos de expansão separados, cada um colocado no ponto correto em uma grade 17 por 17, para que eles passem pelo quadrado central da grade (ou seja, o quadrado da imagem) em os momentos certos para dar a impressão do nível atual de reflexão necessário. É simples (e curto!) De codificar, mas corre bem devagar ...