Matematyka liczb całkowitych może generować niesamowite wzory, gdy zostaną ułożone na siatce. Nawet najbardziej podstawowe funkcje mogą przynieść oszałamiająco dopracowane projekty!

Twoje wyzwanie

Napisz 3 tweetyty (czyli 140 znaków lub mniej) funkcji dla wartości czerwonego, zielonego i niebieskiego dla obrazu 1024x1024.

Wejściowymi funkcjami będą dwie liczby całkowite i (numer kolumny dla danego piksela) i j (numer wiersza dla danego piksela), a wynikiem będzie skrót bez znaku między 0 a 1023 włącznie, który reprezentuje ilość danego kolor obecny w pikselu (i, j).

Na przykład następujące trzy funkcje tworzą poniższy obraz:

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

Zasady

• Biorąc pod uwagę ten kod C ++ , zastępuj w swoich funkcjach. Udostępniłem kilka makr i załączyłem bibliotekę, a ty możesz dołączyć complex.h. Możesz używać dowolnych funkcji z tych bibliotek i / lub moich makr. Proszę nie używać żadnych zewnętrznych zasobów poza tym.

• Jeśli ta wersja nie działa dla Ciebie, upewnij się, że kompilujesz:

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

  Jeśli to nie zadziała, użyj alternatywnej wersji, używając znaków bez znaku zamiast skrótów bez znaku.

Michaelangelo dostarczył oczyszczoną 24-bitową lub 48-bitową wersję kolorową .

• Możesz zaimplementować własną wersję w innym języku, ale musi ona zachowywać się w taki sam sposób, jak dostarczona wersja C ++, a tylko funkcje z wbudowanych C ++, biblioteki lub dostarczonych makr mogą być użyte do zapewnienia uczciwości.
• Publikuj tylko trzy ciała funkcji - proszę nie dołączaj mojego kodu do swojego postu
• Podaj mniejszą wersję lub osadzoną kopię obrazu. Są one tworzone w formacie ppm i może być konieczne ich przekonwertowanie na inny w celu poprawnego przeglądania na stosie wymiany.
• Ciała funkcji (bez podpisu) muszą mieć maksymalnie 140 znaków.
• To konkurs popularności - najwięcej głosów wygrywa

Mandelbrot 3 x 133 znaków

Pierwszą rzeczą, jaka przyszła mi do głowy, było „Mandelbrot!”.

Tak, wiem, że jest już zgłoszenie mandelbrota. Po potwierdzeniu, że sam jestem w stanie uzyskać poniżej 140 znaków, podjąłem sztuczki i optymalizacje z tego rozwiązania do mojego (dzięki Martin i Todd). Zostało miejsce na wybranie interesującej lokalizacji i powiększenia, a także ładny motyw kolorystyczny:

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

Łącznie 132 znaki

Starałem się obniżyć do 140 dla wszystkich 3 kanałów. W pobliżu krawędzi jest trochę szumu koloru, a lokalizacja nie jest tak interesująca jak pierwsza, ale: 132 znaki

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

Obrusy

Mieszkanie

Zacząłem umieszczać wzór kratki / bawełniany materiał w kratkę w perspektywie jak nieograniczony obrus:

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

Marszczyć

Następnie wprowadziłem tętnienie (nie do końca poprawna perspektywa, ale wciąż w 140 znakach):

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

Kolor

Następnie niektóre kolory były bardziej drobnoziarniste, aby nadać detalom szerszy zakres skali i aby obraz był bardziej kolorowy ...

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

W ruchu

Nieznaczne zmniejszenie kodu pozwala na zdefiniowanie fazy fali P z 2 miejscami po przecinku, co wystarcza dla klatek wystarczająco blisko, aby uzyskać płynną animację. Na tym etapie zmniejszyłem amplitudę, aby uniknąć wywoływania choroby morskiej, i przesunąłem cały obraz o kolejne 151 pikseli (kosztem 1 dodatkowego znaku), aby zepchnąć aliasing z górnej części obrazu. Animowane aliasing jest hipnotyzujące.

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

Losowy malarz

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

Oto wpis oparty na losowości. Dla około 0,1% pikseli wybiera losowy kolor, dla pozostałych używa tego samego koloru co losowy sąsiadujący piksel. Zauważ, że każdy kolor robi to niezależnie, więc jest to po prostu nakładka losowego obrazu zielonego, niebieskiego i czerwonego. Aby uzyskać różne wyniki dla różnych przebiegów, musisz dodać srand(time(NULL))do mainfunkcji.

Teraz kilka wariantów.

Pomijając piksele, możemy uczynić go nieco bardziej rozmytym.

Następnie możemy powoli zmieniać kolory, w których przelewy powodują gwałtowne zmiany, które sprawiają, że wygląda to bardziej jak pociągnięcia pędzlem

Co muszę wymyślić:

• Z jakiegoś powodu nie mogę wprowadzić srandtych funkcji bez uzyskania segfault.
• Gdybym mógł sprawić, by losowe spacery były takie same we wszystkich trzech kolorach, mogłoby to wyglądać nieco bardziej uporządkowany.

Możesz także ustawić izotropowy losowy spacer

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

dać Ci

Więcej przypadkowych obrazów

Bawiłem się tym trochę więcej i stworzyłem inne losowe obrazy. Nie wszystkie z nich są możliwe w ramach ograniczeń tego wyzwania, więc nie chcę ich tutaj uwzględniać. Ale możesz je zobaczyć w tej galerii imgur wraz z niektórymi opisami tego, jak je wyprodukowałem.

Kusi mnie, aby rozwinąć wszystkie te możliwości w ramy i umieścić je w GitHub. (Nie to, że takie rzeczy już nie istnieją, ale i tak jest zabawne!)

Niektóre swirly spiczaste rzeczy

Tak, wiedziałem dokładnie, jak to nazwać.

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

EDYCJA: Nie używa już pow. EDYCJA 2: @PhiNotPi zwrócił uwagę, że nie muszę tak często używać abs.

Możesz łatwo zmienić punkty odniesienia, aby uzyskać inny obraz:

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 zwrócił uwagę, że moje zdjęcia zawierają Batmana.

Oczywiście musi być zgłoszenie Mandelbrota.

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

Próbuję teraz ulepszyć schemat kolorów. Czy to oszustwo, jeśli zdefiniuję obliczenie jako makro red_fni użyję tego makra w pozostałych dwóch, więc mam więcej znaków do fantazyjnego wyboru kolorów w kolorze zielonym i niebieskim?

Edycja: Naprawdę trudno jest wymyślić przyzwoite schematy kolorów z tymi kilkoma pozostałymi bajtami. Oto jeszcze jedna wersja:

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

I zgodnie z sugestią githubphagocyte i dzięki ulepszeniom Todda Lehmana, możemy łatwo wybrać mniejsze sekcje:

Na przykład

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

daje

Julia ustawia się

Jeśli jest Mandelbrot, powinien być też zestaw Julii.

Możesz spędzić godziny na ulepszaniu parametrów i funkcji, więc jest to szybki, który wygląda przyzwoicie.

Zainspirowany udziałem Martina.

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

Czy chciałbyś trochę RNG?

OK, komentarz Sparra postawił mnie na tropie, aby losowo dobrać parametry tych małych Julias. Najpierw próbowałem przeprowadzić hackowanie na poziomie bitów z wynikiem, time(0)ale C ++ nie pozwala na szesnastkowe liczb zmiennoprzecinkowych, więc był to ślepy zaułek (przynajmniej z moją ograniczoną wiedzą). Mógłbym użyć do tego ciężkiego rzutowania, ale to nie zmieściłoby się w 140 bajtach.

I tak nie zostało mi dużo miejsca, więc musiałem upuścić czerwoną Julię, aby umieścić moje makra i mieć bardziej konwencjonalny RNG ( timed seed i real rand(), woohoo!).

Ups, czegoś brakuje. Oczywiście parametry te muszą być statyczne, w przeciwnym razie masz dziwne wyniki (ale zabawne, może zbadam trochę później, jeśli znajdę coś interesującego).

Więc oto mamy tylko zielone i niebieskie kanały:

Dodajmy teraz prosty czerwony wzór, aby wypełnić pustkę. Nie bardzo pomysłowe, ale nie jestem programistą graficznym ... jeszcze :-)

I wreszcie nowy kod z losowymi parametrami:

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

Pozostało już miejsce ...

Ten jest interesujący, ponieważ w ogóle nie używa parametrów i, j. Zamiast tego pamięta stan w zmiennej statycznej.

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)

Edycja: Teraz jest to właściwy Buddhabrot!

Edycja: Udało mi się ograniczyć intensywność kolorów do limitu bajtów, więc nie ma już fałszywie czarnych pikseli z powodu przepełnienia.

Naprawdę chciałem przestać po czwartej ... ale ...

To ulega nieznacznej kompresji podczas przesyłania (i zmniejsza się po osadzeniu), więc jeśli chcesz podziwiać wszystkie szczegóły, oto interesujące fragment 512x512 (który nie jest skompresowany i jest wyświetlany w pełnym rozmiarze):

Dzięki githubphagocyte za pomysł. Wymagało to nieco skomplikowanego nadużycia wszystkich trzech funkcji kolorów:

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

Zostało jeszcze kilka bajtów dla lepszego schematu kolorów, ale jak dotąd nie znalazłem niczego, co przewyższałoby obraz w skali szarości.

Podany kod wykorzystuje 4096 x 4096 punktów początkowych i wykonuje do 500 000 iteracji na każdym z nich, aby ustalić, czy trajektorie uciekają, czy nie. Na moim komputerze zajęło to od 6 do 7 godzin. Możesz uzyskać przyzwoite wyniki z siatką 2k na 2k i iteracjami 10k, co zajmuje dwie minuty, a nawet tylko siatka 1k na 1k z iteracjami 1k wygląda całkiem ładnie (to zajmuje 3 sekundy). Jeśli chcesz bawić się tymi parametrami, musisz zmienić kilka miejsc:

• Aby zmienić głębokość rekurencji Mandelbrota, dostosuj oba wystąpienia 5e5in BLdo liczby iteracji.
• Aby zmienić rozdzielczość siatki, zmień wszystkie cztery 4096w RDdo żądanej rozdzielczości, a1024. in GRprzez ten sam czynnik w utrzymaniu prawidłowego skalowania.
• Prawdopodobnie będzie też trzeba przeskalować return c[i][j]in GRponieważ zawiera tylko bezwzględnej liczby odwiedzin każdego piksela. Maksymalny kolor wydaje się być w większości niezależny od liczby iteracji i skaluje się liniowo z całkowitą liczbą punktów początkowych. Więc jeśli chcesz używać siatki 1k na 1k, możesz chcieć return c[i][j]*16;lub podobnie, ale ten czynnik czasami wymaga trochę majstrowania.

Dla tych, którzy nie są zaznajomieni z Buddhabrotem (jak ja kilka dni temu), jest on oparty na obliczeniach Mandelbrota, ale intensywność każdego piksela to częstotliwość odwiedzania tego piksela w iteracjach uciekających trajektorii. Jeśli liczymy wizyty podczas nieuchwytnych trajektorii, to jest to Antibuddhabrot. Istnieje jeszcze bardziej wyrafinowana wersja o nazwie Nebulabrot, w której używasz innej głębokości rekurencji dla każdego kanału kolorów. Ale zostawię to komuś innemu. Aby uzyskać więcej informacji, jak zawsze, Wikipedia .

Początkowo nie rozróżniałem trajektorii ucieczki i ucieczki. To wygenerowało fabułę, która jest połączeniem Buddhabrota i Antibuddhabrota (jak wskazał 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;
}

Ten wygląda trochę jak wyblakłe zdjęcie ... Lubię to.

Sierpiński Pentagon

Być może widziałeś metodę chaosu przybliżania Trójkąta Sierpińskiego przez wykreślanie punktów w połowie drogi do losowo wybranego wierzchołka. Tutaj zastosowałem to samo podejście przy użyciu 5 wierzchołków. Najkrótszy kod, na którym mogłem się zgodzić, zawierał kodowanie na 5 wierzchołków i nie było mowy, żebym zmieścił to wszystko w 140 znakach. Delegowałem więc czerwony komponent do prostego tła i wykorzystałem wolne miejsce w funkcji czerwonej do zdefiniowania makra, aby pozostałe dwie funkcje również były poniżej 140. Tak więc wszystko jest ważne kosztem braku czerwonego elementu w pięciokącie.

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

Podziękowania dla Martina Büttnera za pomysł wspomniany w komentarzach do pytania o zdefiniowaniu makra w jednej funkcji, aby następnie użyć go w innej, a także za użycie zapamiętywania do wypełnienia pikseli w dowolnej kolejności zamiast ograniczania się do kolejności rastrowej funkcji głównej .

Obraz ma ponad 500 KB, więc jest automatycznie konwertowany do formatu jpg przez zamianę stosu. To zaciera niektóre drobniejsze szczegóły, więc dołączyłem również prawą górną ćwiartkę jako png, aby pokazać oryginalny wygląd:

Nuty

Muzyka Sierpińskiego. : D Faceci na czacie mówią, że bardziej przypomina dziurkowany papier do pozytywek.

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

Kilka szczegółów na temat tego, jak to działa ... właściwie to tylko powiększenie renderowania falistych trójkątów Sierpińskiego. Wygląd partytury (a także blokowanie) jest wynikiem obcięcia liczb całkowitych. Jeśli zmienię funkcję czerwoną na powiedzmy

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

obcięcie jest usuwane i otrzymujemy renderowanie w pełnej rozdzielczości:

Tak, to interesujące.

Generator diagramów losowych Voronoi ktoś?

OK, ten sprawił mi trudność. Myślę, że to całkiem miłe, nawet jeśli wyniki nie są tak pomysłowe jak niektóre inne. To jest kwestia losowości. Być może niektóre obrazy pośrednie wyglądają lepiej, ale naprawdę chciałem mieć w pełni działający algorytm ze schematami voronoi.

Edytować:

To jest jeden przykład końcowego algorytmu. Obraz jest w zasadzie superpozycją trzech diagramów voronoi, po jednym dla każdego składnika koloru (czerwony, zielony, niebieski).

Kod

wersja nieposkromiona, na końcu komentowana

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

Zajęło mi to wiele wysiłku, więc mam ochotę dzielić się wynikami na różnych etapach, a są fajne (nieprawidłowe) do pokazania.

Pierwszy krok: umieść niektóre punkty losowo, używając x=y

Przekształciłem go w JPEG, ponieważ oryginalny plik PNG był zbyt ciężki do przesłania (>2MB ), założę się, że to o ponad 50 odcieni szarości!

Po drugie: mieć lepszą współrzędną y

Nie mogłem sobie pozwolić na kolejną tabelę współrzędnych generowanych losowo dla yosi, dlatego potrzebowałem prostego sposobu, aby uzyskać „ losowe ” liczby jak najmniejszej liczby znaków. Wybrałem xwspółrzędną innego punktu w tabeli, wykonując bitowe ANDindeks indeksu punktu.

3. Nie pamiętam, ale robi się przyjemnie

Ale w tym czasie miałem ponad 140 znaków, więc musiałem trochę pograć w golfa.

4-ty: linie skanowania

Żartowałem, to nie jest pożądane, ale trochę fajne, myśli.

Nadal pracuję nad zmniejszeniem rozmiaru algorytmu, z dumą mogę przedstawić:

Edycja StarFox

Voronoi Instagram

5.: zwiększ liczbę punktów

Mam teraz działający fragment kodu, więc przejdźmy od 25 do 60 punktów.

Trudno to zobaczyć tylko na jednym zdjęciu, ale prawie wszystkie punkty znajdują się w tym samym yzakresie. Oczywiście nie zmieniłem operacji bitowej, &42jest o wiele lepszy:

I oto jesteśmy w tym samym momencie, co pierwsze zdjęcie z tego postu. Wyjaśnijmy teraz kod dla tych, które byłyby zainteresowane.

Kod niepoznany i wyjaśniony

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

Dzięki za przeczytanie do tej pory.

Fraktal Lyapunowa

Ciąg użyty do wygenerowania tego to AABAB, a przestrzeń parametrów to [2,4] x [2,4]. (tutaj wyjaśnienie ciągu znaków i przestrzeni parametrów )

Przy ograniczonej przestrzeni kodu myślałem, że ta kolorystyka jest całkiem fajna.

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

Wykonałem również odmianę zestawu Mandelbrot. Wykorzystuje mapę podobną do mapy zestawu Mandelbrota. Powiedz M (x, y) to mapa Mandelbrota. Zatem M (sin (x), cos (y)) jest mapą, której używam, i zamiast sprawdzania wartości uciekających, używam x, i y, ponieważ są one zawsze ograniczone.

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

EDYTOWAĆ

Po dużym bólu w końcu udało mi się stworzyć gif z drugiego obrazu morfingu. Oto on:

Ponieważ jednorożce.

Nie mogłem uzyskać wersji OP z unsigned shortwartościami kolorów do 1023, więc dopóki to nie zostanie naprawione, tutaj jest wersja z charmaksymalną wartością koloru i 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);
}

Wzgórza logistyczne

Funkcje

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

Nie golfił

Wszystkie # definicje mają zmieścić BL poniżej 140 znaków. Oto niezgolfowana wersja niebieskiego algorytmu, nieco zmodyfikowana:

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

Gdy wartości x spadają najczęściej dla danej wartości r (wartość j), wykres staje się jaśniejszy (zwykle przedstawiany jako ciemniejszy).

Diffusion Limited Aggregation

Zawsze fascynowała mnie agregacja z ograniczoną dyfuzją i liczba różnych sposobów, w jaki wygląda ona w prawdziwym świecie.

Trudno mi było napisać to w zaledwie 140 znakach na funkcję, więc musiałem zrobić kod okropny (lub piękny, jeśli lubisz takie rzeczy jak ++d%=4i for(n=1;n;n++)). Trzy funkcje kolorów wywołują się nawzajem i definiują makra, które mają być używane, więc nie czyta się dobrze, ale każda funkcja ma nieco mniej niż 140 znaków.

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

Aby zwizualizować, w jaki sposób cząsteczki stopniowo się agregują, tworzyłem zdjęcia w regularnych odstępach czasu. Każda ramka została wyprodukowana przez zastąpienie 1 calafor(n=1;n;n++) cala 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. To utrzymywało go poniżej 140 znaków dla każdego uruchomienia.

Widać, że agregaty rosnące blisko siebie pozbawiają się cząstek i rosną wolniej.

Wprowadzając niewielką zmianę w kodzie, można zobaczyć pozostałe cząstki, które nie zostały jeszcze przyłączone do agregatów. Pokazuje to gęstsze regiony, w których wzrost nastąpi szybciej, oraz bardzo rzadkie regiony między agregatami, w których wzrost nie może nastąpić z powodu zużycia wszystkich cząstek.

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

Można to animować w taki sam sposób, jak wcześniej:

Spirala (dokładnie 140)

Jest to dokładnie 140 znaków, jeśli nie uwzględnisz nagłówków funkcji i nawiasów. Jest to taka złożona spirala, jaką mogłem zmieścić w limicie postaci.

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

Stopniowo budowałem na prostej spirali, dodając wzory do krawędzi spirali i eksperymentując z tym, jak można łączyć różne spirale, aby wyglądać fajnie. Oto wersja bez golfa z komentarzami wyjaśniającymi, co robi każdy kawałek. Bałagan z parametrami może dać interesujące wyniki.

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

Bałagan z parametrami:

Tutaj spirale są ustawione w linii, ale mają różne wzory krawędzi. Zamiast blokowych krawędzi w głównym przykładzie ma to krawędzie całkowicie złożone z fal grzechu.

Tutaj gradient został usunięty:

Animacja ( która z jakiegoś powodu nie wydaje się być zapętlona po przesłaniu, przepraszam. Musiałem ją również zmniejszyć. Po prostu otwórz ją w nowej karcie, jeśli przegapiłeś animację ):

A oto album imgur ze wszystkimi obrazami. Chciałbym zobaczyć, czy ktoś może znaleźć inne fajne wzory spiralne. Muszę też powiedzieć, że jest to zdecydowanie jedno z najfajniejszych wyzwań, jakie kiedykolwiek widziałem. Cieszyć się!

EDYCJA: Oto niektóre tła wykonane z tych spiral o zmienionych parametrach.

Łącząc moje wzory krawędzi spirali z niektórymi fraktalami, które widziałem tutaj za pomocą operacji xor / i / lub operacji, oto ostatnia spirala:

Hołd dla klasyka

V1 : Zainspirowany materiałem „Bądź szczęśliwy” DreamWarrior, ten prosty przekaz zawiera mały obraz pikselowy w każdym kanale kolorów. Nie musiałem nawet grać w golfa na kod!
V2 : teraz ze znacznie krótszym kodem i grubą czarną ramką izolującą tylko „ekran gry”.
V3 : statek kosmiczny, kula, uszkodzeni kosmici i niebieska ramka, o rany! Z grubsza staram się do tego dążyć .

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

Zdarzyło mi się natrafić na edycję Umber Ferrule, której awatar zainspirował mnie do dodania kolejnego wpisu opartego na pikselach. Ponieważ podstawowa idea kodu jest w dużej mierze podobna do Space Space Invaders, dołączam go do tego wpisu, chociaż oba zdecydowanie miały różne trudne punkty. W tym przypadku poprawienie koloru różowego (kosztem bieli) i fakt, że jest to dość duży duszek, okazało się niezłym wyzwaniem. Szesnastkowe sekwencje specjalne ( \xFFitp.) W czerwonym kanale reprezentują odpowiadające im znaki w pliku źródłowym (to znaczy czerwony kanał w pliku źródłowym zawiera dane binarne), podczas gdy ósemkowe sekwencje specjalne są dosłowne (tj. Obecne w pliku źródłowym).

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

Malowanie akcji

Chciałem spróbować odtworzyć coś podobnego do dzieła Jacksona Pollocka - kapanie i polewanie farbą poziomego płótna. Chociaż podobały mi się wyniki, kod był o wiele za długi, aby opublikować to pytanie, a moje najlepsze wysiłki nadal ograniczały go do około 600 bajtów. Tak więc kod zamieszczony tutaj (który ma funkcje odpowiednio 139 bajtów, 140 bajtów i 140 bajtów) został opracowany z ogromną pomocą niektórych geniuszy na czacie . Ogromne podziękowania dla:

• Eric Tressler
• Robaczek świętojański
• PhiNotPi
• Martin Büttner

na bezustanną sesję golfa w grupie.

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}

Makro E (q) jest używane w funkcjach RD i GR. Zmiana wartości argumentu zmienia sposób, w jaki zmieniają się czerwone i zielone składniki kolorów. Makro J kończy się liczbą, która służy do określenia, jak bardzo zmienia się niebieski komponent, co z kolei wpływa na komponenty czerwony i zielony, ponieważ są one z niego obliczane. Dołączyłem kilka zdjęć z czerwonymi i zielonymi argumentami E zróżnicowanymi, aby pokazać różnorodność możliwych kombinacji kolorów. Najedź kursorem na zdjęcia, aby zobaczyć wartości czerwone i zielone, jeśli chcesz je uruchomić samodzielnie.

Wszystkie te obrazy można wyświetlić w pełnym rozmiarze, jeśli je pobrzesz. Rozmiar pliku jest niewielki, ponieważ płaski kolor odpowiada algorytmowi kompresji PNG, więc nie było wymagane kompresowanie stratne w celu przesłania na stronę.

Jeśli chcesz zobaczyć obrazy z różnych etapów gry w golfa, gdy wypróbowaliśmy różne rzeczy, możesz zajrzeć na czacie malowania akcji .

Pomyślałem, że pobawię się parametrami tego kodu ... Całe podziękowania należą się @Manuel Kasten. Są tak fajne, że nie mogłem się oprzeć opublikowaniu.

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

Edycja: To jest teraz poprawna odpowiedź, dzięki deklaracjom przesyłania dalej GRiBL .

Baw się dobrze z sekwencją Q Hofstadtera! Jeśli używamy odległości radialnej od jakiegoś punktu jako wejścia i wyjścia jako koloru odwrotnego, otrzymujemy coś, co wygląda jak kolorowy winyl.

Sekwencja jest bardzo podobna do sekwencji Fibonacciego, ale zamiast cofnąć się o 1 i 2 kroki wstecz, bierzesz dwie poprzednie wartości, aby ustalić, jak daleko cofnąć się przed pobraniem sumy. Rośnie mniej więcej liniowo, ale od czasu do czasu dochodzi do wybuchu chaosu (w rosnących odstępach), który następnie ustala się ponownie w niemal liniowej sekwencji przed następnym wybuchem:

Możesz zobaczyć te zmarszczki na obrazie po regionach, które wyglądają bardzo „płasko” w kolorze.

Oczywiście używanie tylko jednego koloru jest nudne.

Teraz kod. Potrzebuję funkcji rekurencyjnej do obliczenia sekwencji. Aby to zrobić, używam, RDgdy jjest negatywne. Niestety, to nie pozostawia wystarczającej liczby znaków do obliczenia wartości czerwonego kanału, więc RDz kolei wywołuje GRz przesunięciem w celu wytworzenia czerwonego kanału.

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

Oczywiście jest to właściwie najprostsze możliwe użycie sekwencji i pozostało mnóstwo znaków. Pożycz go i rób z nim inne szalone rzeczy!

Oto kolejna wersja, w której granica i kolory są określone przez sekwencję Q. W tym przypadku było wystarczająco dużo miejsca RD, że nie potrzebowałem nawet deklaracji przekazania:

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

Oblicza to transformację Joukowskiego zbioru koncentrycznych kół wyśrodkowanych w punkcie lekko odsuniętym od początku. Lekko zmodyfikowałem intensywności w niebieskim kanale, aby uzyskać nieco zmienności kolorów.

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

Cel C

Przepisz kod C ++ w Objective-C, ponieważ nie udało mi się go skompilować ... Dał takie same wyniki jak inne odpowiedzi, kiedy działałem na iPadzie, więc to wszystko dobrze.

Oto moje zgłoszenie:

Kod za tym jest dość prosty:

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

Można powiększyć kwadratów przez pomnożenie ii jprzez 0.5, 0.25itd., Zanim zostaną one przetworzone.

Rozprysk farby Sierpińskiego

Chciałem grać więcej kolorami, więc zmieniałem swoją drugą odpowiedź (swirly) i ostatecznie z tym skończyłem.

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

To teraz mój awatar. : P

Czuję się zmuszony do przesłania tego wpisu, który nazywam „niezdefiniowanym zachowaniem”, które zilustruje działanie kompilatora w przypadku funkcji, które powinny zwracać wartość, ale nie:

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

Wszystkie czarne piksele:

Pseudolosowe piksele:

I oczywiście wiele innych możliwych wyników w zależności od kompilatora, komputera, menedżera pamięci itp.

groovy

Tylko kilka trygonometrii i dziwne sztuczki makro.

R & D:

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

EDYCJA: jeśli M_PInie jest dozwolona z powodu obecności tylko w systemach kompatybilnych z POSIX, można ją zastąpić literałem 3.14.

Nie jestem dobry z matematyki. Zawsze byłem biednym uczniem na lekcji matematyki. Więc zrobiłem prosty.

Użyłem zmodyfikowanego kodu JavaScript użytkownika 1455003 . I to jest mój pełny kod .

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

Jest bardzo krótki, więc wszystkie trzy funkcje mieszczą się w jednym tweecie.

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

Kolejne bardzo krótkie funkcje. Znalazłem ten wzór sierpińskiego (i pewien wzór styczny), gdy bałaganiłem różne funkcje matematyczne. To jest pełny kod

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

Inna wersja. ciała funkcyjne są tweetowane.

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

Zmieniona funkcja renderowania obrazu. 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)
}

Purpurowy

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

Malarz Planetarny

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

Zainspirowany oczywiście niesamowitym wejściem Martina , jest to inne podejście. Zamiast losowego rozsiewania części pikseli, zaczynam od lewego górnego rogu jako RGB (512 512 512) i stamtąd przechodzę losowo po każdym kolorze. Wynik wygląda jak coś z teleskopu (imo).

Każdy piksel bierze średnią pikseli powyżej / po lewej stronie i dodaje trochę losowości. Możesz grać ze zmiennością, zmieniającp zmienną, ale myślę, że używam dobrej równowagi (głównie dlatego, że lubię niebieski, więc większa zmienność rozmycia daje dobre wyniki).

Podczas uśredniania występuje nieznaczne ujemne odchylenie od podziału na liczby całkowite. Myślę jednak, że to działa i daje ładny efekt zaciemnienia w dolnym rogu.

Oczywiście, aby uzyskać więcej niż jeden wynik, musisz dodać srand()linię do swojej głównej funkcji.

Odbite fale

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

Podstawowy wzór szachownicy zniekształcony zgodnie z pozycją fali rozszerzającej się z punktu przypominającego kamień upuszczony do stawu (bardzo daleki od fizycznie dokładnego!). Zmienna wto liczba pikseli od tego punktu, w którym przesunęła się fala. Jeśli wjest wystarczająco duża, fala odbija się od boków obrazu.

w = 225

w = 360

w = 5390

Oto GIF przedstawiający kolejne obrazy wraz ze wzrostem fali. Podałem kilka różnych rozmiarów, z których każda pokazuje tyle klatek, ile pozwala limit rozmiaru pliku 500 KB.

Jeśli znajdę sposób, aby to dopasować, idealnie chciałbym mieć modelowanie interferencji fal, aby fale wyglądały bardziej realistycznie, gdy się krzyżują. Jestem jednak zadowolony z tej refleksji.

Zauważ, że tak naprawdę nie modelowałem odbicia fali w 3 partiach po 140 bajtów. Tak naprawdę nie ma refleksji, po prostu tak to wygląda. Ukryłem wyjaśnienie na wypadek, gdyby ktoś chciał zgadnąć w pierwszej kolejności:

Pierwsza fala odbita jest identyczna z falą pochodzącą z drugiej strony krawędzi obrazu, w tej samej odległości od pierwotnego punktu. Tak więc kod oblicza prawidłową pozycję dla 4 punktów wymaganych do uzyskania efektu odbicia od każdej z 4 krawędzi. Dalsze poziomy fali odbitej są identyczne z falą pochodzącą z dalszej płytki, jeśli wyobrażasz sobie obraz jako jedną płytkę w płaszczyźnie. Kod daje iluzję 8 poziomów odbicia, wyświetlając 189 oddzielnych rozszerzających się okręgów, z których każdy jest umieszczony we właściwym punkcie na siatce 17 na 17, tak aby przechodziły przez centralny kwadrat siatki (to znaczy kwadrat obrazu) na odpowiedni moment, aby sprawić wrażenie wymaganego obecnego poziomu odbicia. Jest to proste (i krótkie!) Do kodowania, ale działa dość wolno ...