Tweetable Mathematical Art [zamknięte]

330

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

Wzór-1

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

Wzór-2

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
Kyle McCormick
źródło
3
Dodano znacznik C ++, ponieważ charakter reguł wyklucza inne języki. Zasadniczo preferujemy wyzwania niezależne od języka, chyba że mają uzasadniony powód, aby wymagać określonego zestawu.
algorytmshark
4
Bliscy wyborcy nazywający to zbyt szeroko, spróbuj najpierw napisać odpowiedź na to pytanie. Jest zaskakująco restrykcyjny ...
trichoplax
8
To moja ulubiona rzecz, którą widziałem tutaj, na zawsze!
David Conrad
4
Podoba mi się, że to pytanie przypomina staroświecką scenę demonstracyjną.
mskfisher,
23
Tego rodzaju pytania zachęcają do uczestnictwa w golfie kodowym . Zasadniczo nie jestem skłonny odpowiadać na proste pytanie w golfa, ponieważ nie jestem pewien, czy dobrze sobie radzę. Przy tego typu pytaniach limit bajtów sprawia, że ​​próbuję prostej odpowiedzi, po drodze uczę się technik gry w golfa, a następnie używam ich do bardziej złożonych odpowiedzi. To jak odskocznia do odpowiedzi na proste pytania golfowe. Myślę, że może to być kluczowe dla przyciągnięcia większej liczby osób.
trichoplax

Odpowiedzi:

120

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:

mandelbrot

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

Łą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

mandelbrot-reduced

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}
Manuel Kasten
źródło
8
Te kolory są wspaniałe!
Martin Ender
Uwielbiam ten, jak dotąd najlepiej wyglądający obraz!
Roy van Rijn,
4
To jest teraz moja tapeta.
Szyfr
209

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

flat table cloth

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

rippled table cloth

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

coloured table cloth

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

animated table cloth

trichopaks
źródło
15
To jest legendarne. (Y) Tak trzymaj. : P
Mohammad Areeb Siddiqui
Ale jak dokładnie realizowany jest ruch? W oryginalnym frameworku nie ma logiki zmiany ramki, prawda?
esteewhy
2
@ esteewhy można tworzyć tylko zdjęcia. GIF pokazuje sekwencję nieruchomych klatek, z których każda została utworzona przez zmianę wartości po #define P. Wymagało to gry w golfa, aby umożliwić dodatkowe postacie #define P 6.03.
trichoplax
4
ZATRZYMAĆ! Czy naprawdę chcesz głosować za najlepszą odpowiedzią? Istnieją pewne daleko bardziej interesujące z nich, jeśli przewijać przez następnych dwóch stronach.
trichoplax
1
Polecam sortowanie odpowiedzi według „najstarszych”, a następnie można zobaczyć, jak rozwinęły się nowe podejścia, gdy pojawiły się nowe odpowiedzi.
trichoplax
192

Losowy malarz

enter image description here

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.

enter image description here

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

enter image description here

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

enter image description here

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

Martin Ender
źródło
12
Kocham je. Nie zdawałem sobie sprawy, że można wziąć pod uwagę sąsiednie piksele bez dostępu do danych pikseli - płynna praca!
trichoplax
1
Bardzo przypomina mi ten stary konkurs, w którym zasady polegały na umieszczaniu piksela każdego koloru na obrazie.
internety są wykonane z catz
2
Łał! Te zdjęcia są absolutnie piękne!
raptortech97
1
Fajna galeria, te radialne są schludne.
internety są zrobione z catz
2
Widzę Reptar : ostatnie zdjęcie w poście (izotropowe), prawy górny kwadrant.
Tim Pederick,
162

Niektóre swirly spiczaste rzeczy

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

Niektóre swirly spiczaste rzeczy

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:

Kilka bardziej spiczastych rzeczy

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.

Ordynans

cjfaure
źródło
1
@JayKominek Nie wiedziałbym, nie byłem wtedy w pobliżu d:
cjfaure
1
@cjfaure oh wow! Dziękuję Ci! wygląda na to, że ostateczna wersja opisu znajduje się na stronie: web.archive.org/web/20031205062033/http : //www.blorf.com/~mrad/... i kod został przeniesiony do sourceforge. zaktualizowane nawet w zeszłym roku! sourceforge.net/projects/libswirlies
Jay Kominek
1
Jeden z moich ulubionych!
Calvin's Hobbies
1
Ten jest ładny - ale nie mogę go w ogóle odtworzyć! Najbliższe, co mogę uzyskać, to kiedy PPM jest generowany niepoprawnie (LSB zamiast MSB), a nawet wtedy wygląda to jak różne mieszane w alfa koła o różnych kolorach.
DreamWarrior,
123

Oczywiście musi być zgłoszenie Mandelbrota.

wprowadź opis zdjęcia tutaj

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;

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

Martin Ender
źródło
12
@tomsmeding Muszę wyznać, że po raz pierwszy wdrożyłem zestaw Mandelbrot.
Martin Ender
2
Choć zestaw ikon Mandelbrota jest ikoniczny (nawiasem mówiąc, +1!), Wygląda na to, że zostawiłeś sobie dość miejsca na dostosowanie parametrów i opublikowanie odpowiedzi z niesamowicie pokręconymi szczegółami głębokiego powiększenia.
trichoplax
1
@ githubphagocyte Już o tym myślałem, ale nie mogłem jeszcze zadawać sobie trudu ponownej kompilacji, ponownego uruchomienia i konwersji za każdym razem, dopóki nie wymyślę przyzwoitych parametrów;). Może to zrobić później. Najpierw jednak muszę wypróbować zupełnie inną funkcję. ;)
Martin Ender
2
@ githubphagocyte w końcu udało się to dodać. dzieki za sugestie!
Martin Ender
2
Dzięki @Todd, zaktualizowałem o to ostateczne zdjęcie. Użyłem 25600 iteracji, co za długo. ;)
Martin Ender
110

Julia ustawia się

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

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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:

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

wprowadź opis zdjęcia tutaj

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

internety wykonane są z Catz
źródło
czy masz miejsce na losowanie parametrów przy każdym uruchomieniu za pomocą srand (czas (0) i rand ()? czy tylko czas (0)?
Sparr
2
Ten ostatni jest na mojej ścianie.
cjfaure
@Sparr zaktualizowany o twoją sugestię. Dobrze się bawiliśmy :-).
internety są wykonane z catz
4
Nie potrafię powiedzieć, co lubię najbardziej: twoją odpowiedź lub twoją nazwę użytkownika
William Barbosa,
107

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

kolorowy

Manuel Kasten
źródło
Interesujące byłoby zobaczyć wyniki tego kodu na różnych platformach / kompilatorach. Wartość RAND_MAX jest bardzo różna i może dawać zupełnie inne obrazy ...
trichoplax
5
Nie powinno to wiele zmienić. (double) rand () / RAND_MAX powinien zawsze znajdować się w zakresie [0,0, 1,0].
Manuel Kasten,
2
To jedno z moich ulubionych!
Calvin's Hobbies
2
Jest nie tylko interesujący - jest piękny!
Martin Thoma,
104

Wizerunek

/* RED */
    int a=(j?i%j:i)*4;int b=i-32;int c=j-32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
/* GREEN */
    int a=(j?i%j:i)*4;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((i+j)/2))^_cb((i-j)*2);
/* BLUE */
    int a=(j?i%j:i)*4;int b=i+32;int c=j+32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
faubi
źródło
3
To jest naprawdę piękne, +1.
Milo
3
To jest mój ulubiony. Wygląda jak profesjonalnie wykonany projekt graficzny. : D
cjfaure
4
Wygląda jak wafel mikroprocesorów. macrophotographer.net/images/ss_rvsi_5.jpg
s0rce
Wygląda jak minimalistyczna tapeta .
AL
1
Wygląda podobnie do tęczowego logo Apple .
LegionMammal978
82

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

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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

Martin Ender
źródło
8
Zrobię z tego kapelusz.
cjfaure
6
Jestem naprawdę zdziwiony, że sprowadziłeś to do 3 partii 140 bajtów. Nowy obraz buddabrot jest piękny.
trichoplax
4
To naprawdę imponujące.
copumpkin
Pierwszy jest naprawdę pomysłowy. Przypomina mi meduzę. +1
Igby Largeman
1
To moje ulubione zgłoszenie. Dobra robota!
thomallen,
76

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 .

pięciokąt

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:

w prawym górnym rogu

trichopaks
źródło
73

Nuty

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

Nuty

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:

Nuty nieblokujące

Tak, to interesujące.

cjfaure
źródło
1
To jest jak Squarepusher transkrybowany do neume
ossifrage
1
@squeamishossifrage Co właśnie oglądałem ...?
cjfaure
:-) Filmy Chrisa Cunninghama trochę dziwne, prawda?
piskliwy ossifrage
14
drugi wygląda, jakby się poruszał, kiedy przewijam stronę
user13267,
5
Podczas przewijania strony ostatnia wydawała się naprawdę poruszać. Ładne złudzenie optyczne.
Kyle Kanos
61

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.

wprowadź opis zdjęcia tutaj

Edytować:

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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.

wprowadź opis zdjęcia tutaj

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.

wprowadź opis zdjęcia tutaj

4-ty: linie skanowania

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

wprowadź opis zdjęcia tutaj wprowadź opis zdjęcia tutaj

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

Edycja StarFox

wprowadź opis zdjęcia tutaj

Voronoi Instagram

wprowadź opis zdjęcia tutaj

5.: zwiększ liczbę punktów

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

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:

wprowadź opis zdjęcia tutaj

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.

internety wykonane są z Catz
źródło
1
Uwielbiam diagramy Voronoi. +1 za umieszczenie go w 3 tweetach!
Martin Ender,
1
To jeden z moich ulubionych. Warianty linii skanowania są bardzo estetyczne.
Fraxtil,
1
Uwielbiam to, jak wyjaśniłeś kod
Andrea
Zrób beczkę!
Starson Hochschild,
drugie zdjęcie na czwartym: scanlines jest piękne.
Khaled.K
57

Fraktal Lyapunowa

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

wprowadź opis zdjęcia tutaj

EDYTOWAĆ

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

Czas na imprezę

Cameron
źródło
11
Miły psychodeliczny wygląd na drugi.
internety są wykonane z kat
4
To są szalone ! +1
cjfaure,
10
Straszny fraktal jest straszny Tob ༎ ຶ ෴ ༎ ຶ ༽
Tobia
1
Cholera, ta sekunda jest przerażająca. Amaximg ile możesz wydostać się z prostego z = z ^ 2 + c.
tomsmeding
4
Gdyby Edward Munch malował fraktale, tak wyglądałby Krzyk .
internets is made from catz
55

Ponieważ jednorożce.

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);
}
Martin Ender
źródło
Chciałbym zobaczyć kanały kolorów indywidualnie. To było by fajne.
klaskać
52

Wzgórza logistyczne

wprowadź opis zdjęcia tutaj

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

Eric Tressler
źródło
3
Aww, myślałem o tym, jak to zrobić wczoraj. +1 za rozszyfrowanie. Właściwie paleta jest naprawdę ładna! :)
Martin Ender
2
Ukradłem ci brudne sztuczki i githubphagocyte, choć biorę odpowiedzialność za brzydkie # definicje. Szczególnie „#define G for (”.
Eric Tressler,
1
wygląda bardziej jak wizualizator grup turniejowych
Kevin L
3
Nie pokazano na górze: zwycięzca umiera
Eric Tressler,
1
Czy mogę uzyskać wydruk tego plakatu? Z 3 wyblakłymi tweetami w tle. :-)
Andrew Cheong,
50

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

agregacja ograniczona przez dyfuzję

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.

animowana agregacja

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

DLA z widocznymi cząsteczkami

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

animowana agregacja z cząsteczkami

trichopaks
źródło
3
Bardzo ciekawe +1.
internety są wykonane z catz
50

Spirala (dokładnie 140)

produkt finalny

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.

krawędzie

Tutaj gradient został usunięty:

bez gradientu

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

animacja

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:

spirala fraktalna

Xleviator
źródło
2
To są fantastyczne! Jeśli spojrzysz na inne odpowiedzi, możesz znaleźć pomysły na grę w golfa jeszcze bardziej, jeśli chcesz więcej miejsca. Kilka odpowiedzi używa #define w jednej funkcji do zdefiniowania makra, z którego wszystkie 3 mogą korzystać, dzięki czemu można przenieść większość obliczeń na inne funkcje kolorów. Martin Büttner zapoznał mnie z tą sztuczką.
trichoplax
Dziękuję Ci! W moim przypadku, o ile mogę znaleźć, w moim kodzie brakuje rodzaju zduplikowanych wzorców logicznych, które skorzystałyby z definicji funta. Jeśli jednak coś takiego zobaczysz, byłbym wdzięczny, gdybyś mógł mi je zidentyfikować, szczególnie biorąc pod uwagę, że od wielu lat nie używam C / C ++.
xleviator
Znalezienie zduplikowanych sekcji rzeczywiście pomogłoby jeszcze bardziej, ale nawet bez powielania możesz po prostu przenieść kod z BL na RD lub GN, definiując go jako makro w RD lub GN, a następnie używając go w BL. To powinno dać ci dwa razy więcej miejsca na dodatkowy kod.
trichoplax
Ach! Widzę. Nawet nie zdawałem sobie sprawy, że każde ciało funkcyjne ma limit 140 znaków. Przypuszczam, że następnym razem powinienem uważniej przeczytać monit. Dziękujemy za zwrócenie na to uwagi!
xleviator
1
Jak omawiano na czacie , twój nie zapętlający się GIF powinien być łatwy do naprawy. Myślę, że warto to zrobić, ponieważ krótki fragment animacji, który obecnie pokazuje, wygląda świetnie.
trichoplax,
47

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;

Space Invaders


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;

Bub (Bubble Bobble)

Robaczek świętojański
źródło
3
Uwielbiam to. Dużo miejsca na dodanie dodatkowych funkcji ...
trichoplax
1
Tak, jest wiele sztuczek, które można pociągnąć, aby zmniejszyć rozmiar. Może spróbuję go przedłużyć jutro.
FireFly,
To jest teraz niezwykle krótkie. Czy możesz dopasować jeden z tych wzorów bitów do tekstury w swojej odpowiedzi raycasting ...?
trichoplax
@ MartinBüttner ups, masz rację. Naprawiłem to i dokonałem kolejnej aktualizacji funkcji.
FireFly,
Fajnie, podoba mi się sposób, w jaki wziąłeś grafikę pikselową 8x8 i „zmieniłeś jej rozmiar” w locie. Musiałem jednak wprowadzić kilka zmian i nadal nie otrzymuję dokładnie twojego wizerunku. Zmieniłem 1L i 255L na 1LL i 255LL. Od kiedy to się poprawiło, zakładam, że prawdopodobnie kompilujesz w trybie 64-bitowym i są pewne problemy z szerokością, które powodują, że reszta mojego obrazu wychodzi źle. Ale wciąż niezła robota!
DreamWarrior,
44

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:

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}

malarstwo akcji 21, 21

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.

malarstwo akcji 14, 14

malarstwo akcji 63, 49

malarstwo akcji 56, 42

malarstwo akcji 0, 49

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 .

trichopaks
źródło
7
Śledzę to pytanie i wszystkie odpowiedzi od kilku tygodni i muszę powiedzieć, że jest to pierwszy, który sprawił, że moja szczęka opadła. ŚWIĘTY NIEZWYKŁOŚĆ. Mam na myśli, że wszystkie odpowiedzi tutaj są świetne - ale tej jest coś, czego nigdy bym się nie spodziewał.
Todd Lehman,
1
@ToddLehman dziękuję! Z pewnością nie jest to coś, na co byłbym zdolny sam - wiem, ponieważ próbowałem ...
trichoplax
2
NIESAMOWITE! Jeden z najlepszych w tym pytaniu i dla mnie jedyny (może poza zwycięzcą), który wygląda jak narysowany przez człowieka :)
cyriel
1
@cyriel wielkie dzięki. Można powiedzieć, że ten został narysowany przez 5 ludzi ...
trichoplax
43

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. Ciepło Zimno

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

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

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

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

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

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

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);
Kyle McCormick
źródło
3
Dla mnie wygląda jak Dr. Seuss. Bardzo fajny!
DLosc
3
Haha, tak naprawdę nazwałem dolne dwa pliki Seuss1 i Sueuss2
Kyle McCormick
42

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.

wprowadź opis zdjęcia tutaj

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:

wprowadź opis zdjęcia tutaj

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.

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

Martin Ender
źródło
1
Ten drugi szary obraz jest oszałamiający!
tomsmeding
Czy można to na tyle spakować, aby korzystać z samych funkcji r / g / b rekurencyjnie, z niepoprawnymi współrzędnymi dla wywołań rekurencyjnych?
Sparr
Uwielbiałem ten wielokolorowy obraz. Niezła odpowiedź!
Alex
41

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

wprowadź opis zdjęcia tutaj

piskliwy kostuch
źródło
39

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:

Obfitość trójkątów

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.

Max Chuquimia
źródło
Czy jesteś pewien, że używałeś tego samego kodu? ^ Wygląda trochę dziwnie, ponieważ (i ^ i) zawsze ma wartość 0 (XOR), a ^ 2 bardziej przypomina kwadrat niż bit XOR.
Manuel Ferreria
1
@ManuelFerreria W przypadku XOR kod jest w rzeczywistości kompilowany w następujący sposób: x^(x-y)^y(to mnie też odrzuciło za pierwszym razem). Jeśli masz możliwości iOS, oto mój kod: gist.github.com/Jugale/28df46f87037d81d2a8f
Max Chuquimia
38

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.

Rozprysk farby Sierpińskiego

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

cjfaure
źródło
4
Dobra robota. proszę pana, dobra robota.
EaterOfCode
37

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:

wszystkie czarne piksele

Pseudolosowe piksele:

pseudolosowe piksele

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

Sparr
źródło
3
Co dostałeś
tomsmeding
3
Dostałem jednolitą czerń i jednolity kolor, który zmieniał się pomiędzy różnymi uruchomieniami programu, z różnymi kompilatorami.
Sparr
8
Mój kompilator po prostu błędy i krzyczy na mnie, że nie zwracam wartości.
Pharap,
3
@Pharap to nie jest zła rzecz :)
Sparr
Wątpię, byś kiedykolwiek dostał tak ładną przypadkowość, jak sugeruje twoje drugie zdjęcie. Stała wartość, indeks pętli itp. Są znacznie bardziej prawdopodobne (cokolwiek jest przechowywane w EAX po wywołaniu funkcji).
przykład
37

groovy

groovy.png

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.

Fraxtil
źródło
1
Mam zapasowe postacie, acos(-1)to dobry zamiennik M_PI.
Martin Ender
33

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

mathpic1.png

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.


mathpic2.png

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

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

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

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

Przekąska
źródło
Właśnie i&jrenderuje trójkąt Sierpińskiego. Co jest niesamowite .
cjfaure
Ten ostatni jest wart zdjęcia profilowego.
mbomb007
32

JavaScript

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

document.body.appendChild(can);

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

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

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

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

USA

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

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

wolfhammer
źródło
OSZUST! OSZUST! ; D (to poprawna odpowiedź, po prostu zbyt sprytna: P Fajna!)
tomsmeding
1
Hahah .. tak wiem, więc przesłałem taki, który jest bardziej zgodny z duchem pytania. Właściwie to próbowałem tworzyć wzory i zastanawiałem się, czy rzeczywiście mogę coś narysować.
wolfhammer,
Możesz sprawić, że obrazy w płytkich kolorach będą wyglądać nieco bogatsze, dodając nieco szumu ziarnistego w niższych bitach, stosując na końcu „| Math.random () * 256”). Sprawia, że ​​ciemniejsze odcienie są bardziej przypadkowo zaburzone bez zmiany rozjaśnienia. (i zwiększ liczbę w zależności od progu ciemności)
Kent Fredric
rgb przypadkowość @ [10 728 728] i.imgur.com/ms4Cuzo.png
Kent Fredric
31

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.

kołnierz sutanny i togi

Geobity
źródło
2
Gdyby obraz był nieco większy, wyglądałby jak promienie światła. o:
cjfaure
1
@cjfaure, jeśli oglądasz obraz w pełnym rozmiarze (pobierz / kliknij prawym przyciskiem myszy i wyświetl obraz / cokolwiek działa w twoim systemie), to wygląda jeszcze piękniej z dodatkowymi szczegółami.
trichoplax
zrób z niego okrąg otoczony czernią, a to sprawi, że będzie to planeta!
Khaled.K
1
Próbowałem owinąć to wokół kuli blenderem i wykonałem animację. Zobacz ti tutaj: gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs
30

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

fale o w = 225

w = 360

fale o w = 360

w = 5390

fale o 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.

fale duży GIF

macha małym GIF-em fale średnie GIF


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

trichopaks
źródło
3
Uwielbiam GIF-y i wyjaśnienia.
DLosc
Neato! Ale stary, takie wpisy każą mi myśleć, że potrzebuję szybszego komputera (lub więcej cierpliwości, lol). Albo twój komputer jest znacznie szybszy, albo nie chcę myśleć, ile czasu zajęło ci wygenerowanie wszystkich ramek GIF.
DreamWarrior,
3
@DreamWarrior To nie ja jestem cierpliwy. To mój laptop nie ma nic przeciwko bieganiu przez noc, kiedy śpię ...
trichoplax
2
Widzę Pacmana na drugim zdjęciu.
AL