Tweetable Mathematical Art [geschlossen]

330

Ganzzahlige Mathematik kann erstaunliche Muster erzeugen, wenn sie über ein Raster gelegt wird. Selbst die grundlegendsten Funktionen können erstaunlich aufwändige Designs ergeben!

Deine Herausforderung

Schreiben Sie für ein 1024x1024-Bild 3 tweetbare (dh 140 Zeichen oder weniger) Funktionskörper für die Werte Rot, Grün und Blau.

Die Eingabe für die Funktionen ist zwei ganze Zahlen i (Spaltennummer für das gegebene Pixel) und j (Zeilennummer für das gegebene Pixel), und die Ausgabe ist ein vorzeichenloser Kurzschluss zwischen 0 und 1023 einschließlich, der die Menge des gegebenen darstellt im Pixel vorhandene Farbe (i, j).

Die folgenden drei Funktionen ergeben beispielsweise das folgende Bild:

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

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

Muster-2

Die Regeln

  • Ersetzen Sie in Anbetracht dieses C ++ - Codes in Ihren Funktionen. Ich habe einige Makros zur Verfügung gestellt und die Bibliothek eingeschlossen, und Sie können complex.h einschließen. Sie können alle Funktionen aus diesen Bibliotheken und / oder meinen Makros verwenden. Verwenden Sie darüber hinaus keine externen Ressourcen.
  • Wenn diese Version für Sie nicht funktioniert, stellen Sie sicher, dass Sie mit Folgendem kompilieren:

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

    Wenn dies nicht funktioniert, verwenden Sie bitte die alternative Version mit nicht unterzeichneten Zeichen anstelle von nicht unterzeichneten Kurzzeichen.

Michaelangelo hat eine bereinigte 24-Bit- oder 48-Bit-Farbausgabeversion bereitgestellt .

  • Sie können Ihre eigene Version in einer anderen Sprache implementieren, sie muss sich jedoch genauso verhalten wie die bereitgestellte C ++ - Version, und es dürfen nur Funktionen aus den integrierten C ++ - Funktionen, der Bibliothek oder den bereitgestellten Makros verwendet werden, um sie fair zu gestalten.
  • Posten Sie nur Ihre drei Funktionskörper - bitte fügen Sie meinen Code nicht in Ihren Beitrag ein
  • Bitte fügen Sie entweder eine kleinere Version oder eine eingebettete Kopie Ihres Bildes bei. Sie werden in ein ppm-Format umgewandelt und müssen möglicherweise in ein anderes konvertiert werden, damit sie beim Stapelaustausch richtig angezeigt werden können.
  • Funktionskörper (ohne Signatur) dürfen maximal 140 Zeichen lang sein.
  • Dies ist ein Beliebtheitswettbewerb - die meisten Stimmen gewinnen
Kyle McCormick
quelle
3
C ++ - Tag hinzugefügt, da die Natur der Regeln andere Sprachen ausschließt. Wir bevorzugen im Allgemeinen sprachunabhängige Herausforderungen, es sei denn, sie erfordern einen bestimmten Satz.
Algorithmushai
4
Bitte versuchen Sie zunächst, eine Antwort auf diese Frage zu schreiben, damit die engen Wähler dies als zu umfassend bezeichnen. Es ist überraschend restriktiv ...
Trichoplax
8
Dies ist meine Lieblingssache, die ich hier gesehen habe!
David Conrad
4
Ich finde es toll, dass sich diese Frage wie eine Demoszene der alten Schule anfühlt.
mskfisher
23
Diese Art von Frage fördert die Teilnahme am Code-Golf . Ich bin im Allgemeinen nicht geneigt, eine reine Golffrage zu beantworten, da ich nicht sicher bin, ob ich gut abschneiden kann. Bei dieser Art von Frage veranlasst mich die Bytegrenze, eine einfache Antwort zu versuchen, währenddessen Golftechniken zu erlernen und diese dann zu komplexeren Antworten zu verwenden. Dies ist wie ein Sprungbrett für die Beantwortung direkter Golffragen. Ich denke, es könnte der Schlüssel sein, um mehr Leute
hereinzubringen

Antworten:

120

Mandelbrot 3 x 133 Zeichen

Das erste, was mir in den Sinn kam, war "Mandelbrot!".

Ja, ich weiß, dass es bereits eine Mandelbrot-Einreichung gibt. Nachdem ich bestätigt habe, dass ich es selbst unter 140 Zeichen schaffen kann, habe ich die Tricks und Optimierungen aus dieser Lösung in meine übernommen (danke Martin und Todd). Das ließ Raum, um einen interessanten Ort und Zoom sowie ein schönes Farbthema zu wählen:

mandelbrot

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

132 Zeichen insgesamt

Ich habe versucht, es für alle 3 Kanäle auf 140 zu bringen. Es gibt ein wenig Farbrauschen in der Nähe des Randes, und die Position ist nicht so interessant wie die erste, aber: 132 Zeichen

mandelbrotreduziert

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
quelle
8
Diese Farben sind wunderschön!
Martin Ender
Ich liebe dieses schönste Bild, das ich je gesehen habe!
Roy van Rijn
4
Das ist jetzt mein Hintergrundbild.
Chiffre
209

Tischdecken

Eben

Ich fing an, ein kariertes / kariertes Muster wie ein grenzenloses Tischtuch in die richtige Perspektive zu rücken:

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

flache Tischdecke

Welligkeit

Dann habe ich eine Welligkeit eingeführt (nicht unbedingt korrekte Perspektive, aber immer noch in 140 Zeichen):

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

gewelltes Tischtuch

Farbe

Dann habe ich einige Farben feiner gemasert, um eine größere Auswahl an Details zu erhalten und das Bild bunter zu machen ...

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

farbige Tischdecke

In Bewegung

Wenn Sie den Code nur geringfügig weiter reduzieren, können Sie eine Wellenphase P mit zwei Dezimalstellen definieren, die gerade für Frames ausreicht, die für eine reibungslose Animation nah genug sind. In diesem Stadium habe ich die Amplitude reduziert, um Seekrankheit zu vermeiden, und das gesamte Bild um weitere 151 Pixel nach oben verschoben (zum Preis von 1 zusätzlichen Zeichen), um das Aliasing vom oberen Rand des Bildes zu entfernen. Animiertes Aliasing ist faszinierend.

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

animierte Tischdecke

Trichoplax
quelle
15
Das ist legendär. (Y) Weiter so. : P
Mohammad Areeb Siddiqui
Aber wie genau wird Bewegung umgesetzt? Im ursprünglichen Framework gibt es keine Frame-Änderungslogik, oder?
Am
2
@esteewhy nur Standbilder können produziert werden. Das GIF zeigt eine Folge von Standbildern, von denen jedes durch Ändern des Werts nach erstellt wurde #define P. Es erforderte Golfspielen, um die zusätzlichen Charaktere zuzulassen #define P 6.03.
Trichoplax
4
HALT! Möchten Sie die Top-Antwort wirklich positiv bewerten? Es gibt einige weitaus interessantere, wenn Sie die nächsten beiden Seiten durchblättern.
Trichoplax
1
Ich empfehle, die Antworten nach "ältesten" zu sortieren, und dann können Sie sehen, wie neue Ansätze entstanden sind, als neue Antworten
eingingen
192

Zufälliger Maler

Bildbeschreibung hier eingeben

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

Hier ist ein zufallsbasierter Eintrag. Für ungefähr 0,1% der Pixel wählt es eine zufällige Farbe, für die anderen verwendet es die gleiche Farbe wie ein zufälliges benachbartes Pixel. Beachten Sie, dass jede Farbe dies unabhängig tut, so dass dies eigentlich nur eine Überlagerung eines zufälligen grünen, blauen und roten Bildes ist. Um bei verschiedenen Läufen unterschiedliche Ergebnisse zu erzielen, müssen Sie srand(time(NULL))die mainFunktion erweitern.

Nun zu einigen Variationen.

Durch Überspringen von Pixeln können wir das Bild etwas verschwommener machen.

Bildbeschreibung hier eingeben

Und dann können wir langsam die Farben ändern, wobei die Überläufe zu plötzlichen Änderungen führen, die das Aussehen von Pinselstrichen noch verstärken

Bildbeschreibung hier eingeben

Dinge, die ich herausfinden muss:

  • Aus irgendeinem Grund kann ich sranddiese Funktionen nicht nutzen, ohne einen Segfault zu erhalten.
  • Wenn ich die zufälligen Bewegungen über alle drei Farben gleich machen könnte, könnte es ein bisschen ordentlicher aussehen.

Sie können den Random Walk auch isotrop machen

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

dir geben

Bildbeschreibung hier eingeben

Mehr zufällige Bilder

Ich habe ein bisschen mehr damit gespielt und ein paar andere zufällige Bilder geschaffen. Nicht alle davon sind im Rahmen dieser Herausforderung möglich, daher möchte ich sie hier nicht aufnehmen. Aber Sie können sie in dieser Bildergalerie sehen, zusammen mit einigen Beschreibungen, wie ich sie hergestellt habe.

Ich bin versucht, all diese Möglichkeiten zu einem Framework zu entwickeln und auf GitHub zu stellen. (Nicht, dass so etwas noch nicht existiert, aber es macht trotzdem Spaß!)

Martin Ender
quelle
12
Ich liebe diese. Mir war nicht klar, dass es möglich sein würde, benachbarte Pixel zu berücksichtigen, ohne Zugriff auf die Pixeldaten zu haben - reibungsloses Arbeiten!
Trichoplax
1
Erinnert mich sehr an diesen alten Wettbewerb, bei dem die Regeln bestanden, ein Pixel jeder Farbe in das Bild einzufügen.
Internet besteht aus Catz
2
Beeindruckend! Diese Bilder sind absolut wunderschön!
Raptortech97
1
Coole Galerie, die radialen sind ordentlich.
Internet besteht aus Catz
2
Ich sehe Reptar : letztes Bild im Beitrag (das isotrope), oberer rechter Quadrant.
Tim Pederick
162

Einige wirbelnde, spitze Dinge

Ja, ich wusste genau, wie ich es nennen sollte.

Einige wirbelnde, spitze Dinge

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

BEARBEITEN: Nicht mehr verwendet pow. EDIT 2: @PhiNotPi wies darauf hin, dass ich nicht so viel abs verwenden muss.

Sie können die Referenzpunkte ziemlich einfach ändern, um ein anderes Bild zu erhalten:

Noch mehr wirbelnde, spitze Dinge

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 wies darauf hin, dass meine Bilder Batman enthalten.

Batman

cjfaure
quelle
1
@ JayKominek Ich würde nicht wissen, ich war damals nicht da d:
cjfaure
2
@ JayKominek Ich habe es gefunden. web.archive.org/web/19990221092445/http://www.blorf.com/…
cjfaure
1
@ cjfaure oh wow! Dankeschön! Die endgültige Version der Beschreibung befindet sich anscheinend unter : web.archive.org/web/20031205062033/http://www.blorf.com/~mrad/… und der Code wurde nach sourceforge verschoben. Letztes Jahr sogar aktualisiert! sourceforge.net/projects/libswirlies
Jay Kominek
1
Eines meiner liebsten!
Calvins Hobbys
1
Dieser ist hübsch - aber ich kann ihn überhaupt nicht reproduzieren! Am nächsten kann ich kommen, wenn das PPM nicht ordnungsgemäß generiert wird (LSB statt MSB) und es auch dann nur wie eine Vielzahl von Alpha-Mischkreisen mit verschiedenen Farben aussieht.
DreamWarrior
123

Natürlich muss es eine Mandelbrot-Einreichung geben.

Bildbeschreibung hier eingeben

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

Ich versuche jetzt, das Farbschema zu verbessern. Ist es ein Betrug, wenn ich die Berechnung als Makro definiere red_fnund dieses Makro in den anderen beiden verwende, damit ich mehr Zeichen für eine ausgefallene Farbauswahl in Grün und Blau habe?

Bearbeiten: Es ist wirklich schwierig, mit diesen wenigen verbleibenden Bytes anständige Farbschemata zu finden. Hier ist eine andere Version:

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

Bildbeschreibung hier eingeben

Und gemäß dem Vorschlag von Githubphagocyte und mit den Verbesserungen von Todd Lehman können wir leicht kleinere Abschnitte auswählen:

Z.B

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

gibt

Bildbeschreibung hier eingeben

Martin Ender
quelle
12
@tomsmeding Ich muss gestehen, dies ist das erste Mal, dass ich das Mandelbrot-Set implementiert habe.
Martin Ender
2
So ikonisch das gesamte Mandelbrot-Set auch ist (übrigens +1!), So scheint es, als hätten Sie gerade genug Platz gelassen, um die Parameter anzupassen und eine Antwort mit einigen der erstaunlich verdrehten Details eines tiefen Zooms zu posten.
Trichoplax
1
@githubphagocyte Ich habe bereits darüber nachgedacht, konnte mich aber noch nicht die Mühe machen, jedes Mal neu zu kompilieren, erneut auszuführen und zu konvertieren, bis ich anständige Parameter herausgefunden habe;). Könnte es später tun. Zuerst muss ich aber eine ganz andere Funktion ausprobieren. ;)
Martin Ender
2
@githubphagocyte endlich dazu gekommen, das hinzuzufügen. danke für den Vorschlag!
Martin Ender
2
Danke @Todd, ich habe das endgültige Bild damit aktualisiert. Ich habe 25600 Iterationen verwendet, das ist zu lange genug. ;)
Martin Ender
110

Julia setzt

Wenn es einen Mandelbrot gibt, sollte es auch einen Julia-Satz geben.

Bildbeschreibung hier eingeben

Sie können stundenlang daran arbeiten, die Parameter und Funktionen zu optimieren. Dies ist also nur eine kurze Anleitung, die anständig aussieht.

Inspiriert von Martins Teilnahme.

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

Möchten Sie etwas RNG?

OK, Sparrs Kommentar hat mich dazu veranlasst, die Parameter dieser kleinen Julias zufällig zu bestimmen. Ich habe zuerst versucht, Hacken auf Bit-Ebene mit dem Ergebnis von durchzuführen, time(0)aber C ++ erlaubt keine hexadezimalen Fließkommazahlen, so dass dies eine Sackgasse war (zumindest mit meinen begrenzten Kenntnissen). Ich hätte ein schweres Casting verwenden können, um es zu erreichen, aber das hätte nicht in die 140 Bytes gepasst.

Ich hatte sowieso nicht mehr viel Platz, also musste ich die rote Julia fallen lassen, um meine Makros zu platzieren und ein konventionelleres RNG ( timed seed und real rand(), woohoo!) Zu haben.

Bildbeschreibung hier eingeben

Hoppla, etwas fehlt. Offensichtlich müssen diese Parameter statisch sein, oder Sie haben einige seltsame Ergebnisse (aber lustig, vielleicht werde ich später nachforschen, ob ich etwas Interessantes finde).

Also hier sind wir mit nur grünen und blauen Kanälen:

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

Fügen wir nun ein einfaches rotes Muster hinzu, um die Lücke zu füllen. Nicht wirklich einfallsreich, aber ich bin kein Grafikprogrammierer ... bis jetzt :-)

Bildbeschreibung hier eingeben

Bildbeschreibung hier eingeben

Und zum Schluss der neue Code mit zufälligen Parametern:

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

Es ist noch Platz übrig ...

Das Internet besteht aus Catz
quelle
Haben Sie Platz, um die Parameter bei jedem Lauf mit srand (Zeit (0) und rand ()? oder nur Zeit (0)?
Sparr
2
Der Letzte geht an meine Wand.
cjfaure
@Sparr mit Ihrem Vorschlag aktualisiert. Hatte ein bisschen Spaß :-).
Internet besteht aus Catz
4
Ich kann nicht sagen, was Ihnen am besten gefällt: Ihre Antwort oder Ihr Benutzername
William Barbosa
107

Dieser ist interessant, weil er die i, j-Parameter überhaupt nicht verwendet. Stattdessen merkt es sich den Zustand in einer statischen Variablen.

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

bunt

Manuel Kasten
quelle
Es wäre interessant, die Ergebnisse dieses Codes auf verschiedenen Plattformen / Compilern zu sehen. Der Wert von RAND_MAX ist sehr unterschiedlich und kann zu völlig unterschiedlichen Bildern führen ...
trichoplax
5
Es sollte sich nicht viel ändern. (double) rand () / RAND_MAX sollte immer im Bereich [0.0, 1.0] liegen.
Manuel Kasten
2
Dies ist einer meiner Favoriten!
Calvins Hobbys
2
Es ist nicht nur interessant - es ist wunderschön!
Martin Thoma
104

Bild

/* 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
quelle
3
Das ist wirklich schön, +1.
Milo
3
Das ist mein Lieblings. Es sieht aus wie ein professionelles Stück Grafikdesign. : D
cjfaure
4
Es sieht aus wie ein Waffel aus Mikroprozessoren. macrophotographer.net/images/ss_rvsi_5.jpg
s0rce
Es sieht aus wie eine minimalistische Tapete .
AL
1
Es sieht ähnlich aus wie das Regenbogen-Apple-Logo .
LegionMammal978
82

Buddhabrot (+ Antibuddhabrot)

Edit: Es ist jetzt ein richtiger Buddhabrot!

Bearbeiten: Ich habe es geschafft, die Farbintensität innerhalb der Bytegrenze zu begrenzen, sodass es aufgrund des Überlaufs keine falsch schwarzen Pixel mehr gibt.

Ich wollte unbedingt nach vier aufhören ... aber ...

Bildbeschreibung hier eingeben

Dies wird beim Hochladen leicht komprimiert (und beim Einbetten verkleinert). Wenn Sie also alle Details bewundern möchten, sehen Sie sich die interessanten 512x512-Ausschnitte an (die nicht komprimiert werden und in voller Größe angezeigt werden):

Bildbeschreibung hier eingeben

Danke an Githubphagocyte für die Idee. Dies erforderte einen ziemlich komplizierten Missbrauch aller drei Farbfunktionen:

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

Für ein besseres Farbschema sind noch einige Bytes übrig, aber bisher habe ich nichts gefunden, was das Graustufenbild übertrifft.

Der angegebene Code verwendet 4096 x 4096 Startpunkte und durchläuft bis zu 500.000 Iterationen, um zu bestimmen, ob die Flugbahnen entkommen oder nicht. Das hat auf meiner Maschine zwischen 6 und 7 Stunden gedauert. Mit einem Raster von 2 x 2 k und Iterationen von 10 k, die zwei Minuten dauern, können Sie gute Ergebnisse erzielen, und selbst ein Raster von 1 x 1 k mit Iterationen von 1 k sieht recht gut aus (das dauert etwa 3 Sekunden). Wenn Sie mit diesen Parametern experimentieren möchten, müssen einige Punkte geändert werden:

  • Passen Sie zum Ändern der Mandelbrot-Rekursionstiefe beide Instanzen von 5e5in BLan Ihre Iterationsanzahl an.
  • Um die Rasterauflösung zu ändern, um alle vier ändern 4096in RDauf die gewünschte Auflösung und die 1024.in GRden gleichen Faktor die richtige Skalierung zu halten.
  • Sie werden wahrscheinlich müssen auch die Skalierung return c[i][j]in GRda , dass nur die absolute Anzahl der Besuche jeden Pixel enthält. Die maximale Farbe scheint weitgehend unabhängig von der Iterationszahl zu sein und skaliert linear mit der Gesamtzahl der Startpunkte. Wenn Sie also ein 1k x 1k-Raster verwenden möchten, möchten Sie vielleicht return c[i][j]*16;oder ähnliches, aber dieser Faktor erfordert manchmal ein wenig Fummeln.

Für diejenigen, die mit dem Buddhabrot nicht vertraut sind (wie ich vor ein paar Tagen), basiert es auf der Mandelbrot-Berechnung, aber die Intensität jedes Pixels gibt an, wie oft dieses Pixel in den Iterationen der entkommenden Flugbahnen besucht wurde. Wenn wir die Besuche während nicht entkommender Flugbahnen zählen, handelt es sich um ein Antibuddhabrot. Es gibt eine noch raffiniertere Version namens Nebulabrot, bei der Sie für jeden Farbkanal eine andere Rekursionstiefe verwenden. Aber ich überlasse das jemand anderem. Weitere Informationen finden Sie wie immer bei Wikipedia .

Ursprünglich habe ich nicht zwischen entkommenen und nicht entkommenen Flugbahnen unterschieden. Das erzeugte eine Handlung, die die Vereinigung eines Buddhabrots und eines Antibuddhabrots ist (wie durch Githubphagozyten hervorgehoben).

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

Bildbeschreibung hier eingeben

Dieser sieht ein bisschen aus wie ein verblasstes Foto ... das gefällt mir.

Martin Ender
quelle
8
Ich werde daraus einen Hut machen.
cjfaure
6
Ich bin wirklich erstaunt, dass Sie dies auf 3 Lose von 140 Bytes gebracht haben. Das neue Buddhabrot-Bild ist wunderschön.
Trichoplax
4
Das ist wirklich beeindruckend.
Copumpkin
Der erste ist wirklich kunstvoll. Erinnert mich an Quallen. +1
Igby Largeman
1
Dieser ist mein Lieblingsbeitrag. Gute Arbeit!
thomallen
76

Sierpinski Pentagon

Möglicherweise haben Sie die Chaos- Spielmethode zur Annäherung an das Sierpinski-Dreieck kennengelernt, indem Sie Punkte auf halbem Weg zu einem zufällig ausgewählten Scheitelpunkt gezeichnet haben. Hier habe ich den gleichen Ansatz mit 5 Eckpunkten gewählt. Der kürzeste Code, auf den ich mich festlegen konnte, beinhaltete die harte Codierung der 5 Eckpunkte, und es gab keine Möglichkeit, alles in 140 Zeichen einzupassen. Daher habe ich die rote Komponente an einen einfachen Hintergrund delegiert und den freien Platz in der roten Funktion verwendet, um ein Makro zu definieren, um die anderen beiden Funktionen auch unter 140 zu bringen. Es gilt also alles auf Kosten der Abwesenheit einer roten Komponente im Fünfeck.

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

Vielen Dank an Martin Büttner für die in den Kommentaren der Frage erwähnte Idee, ein Makro in einer Funktion zu definieren, um es dann in einer anderen zu verwenden, und für die Verwendung von Memoization, um die Pixel in einer willkürlichen Reihenfolge zu füllen, anstatt auf die Rasterreihenfolge der Hauptfunktion beschränkt zu sein .

Pentagon

Das Bild hat eine Größe von über 500 KB und wird durch Stapelaustausch automatisch in JPG konvertiert. Dies verwischt einige der feineren Details, daher habe ich auch nur das obere rechte Viertel als PNG eingefügt, um den ursprünglichen Look zu zeigen:

oben rechts

Trichoplax
quelle
73

Noten

Sierpinski-Musik. : D Die Leute im Chat sagen, es sieht eher aus wie das gelochte Papier für Spieluhren.

Notenblätter

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

Einige Details, wie das funktioniert ... ähm, es ist eigentlich nur ein Zoom auf ein Rendering einiger gewellter Sierpinski-Dreiecke. Der Noten-Look (und auch die Blockhaftigkeit) ist das Ergebnis von Integer-Kürzungen. Wenn ich die rote Funktion ändere, sagen wir

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

Die Kürzung wird entfernt und wir erhalten die volle Auflösung rendern:

Nicht blockierende Noten

Also ja, das ist interessant.

cjfaure
quelle
1
Es ist wie Squarepusher in transkribiert Neumen
zimperlich ossifrage
1
@squeamishossifrage Was habe ich gerade gesehen ...?
cjfaure
:-) Chris Cunninghams Videos sind ein bisschen seltsam, oder?
Squeamish Ossifrage
14
Der zweite sieht aus, als würde er sich bewegen, wenn ich durch die Seite
scrolle
5
Beim Scrollen durch die Site schien sich die letzte wirklich zu bewegen. Schöne optische Täuschung.
Kyle Kanos
61

Zufälliger Voronoi-Diagrammgenerator jemand?

OK, dieser hat mir eine harte Zeit bereitet. Ich finde es aber ziemlich schön, auch wenn die Ergebnisse nicht so kunstvoll sind wie bei einigen anderen. Das ist der Deal mit Zufälligkeit. Vielleicht sehen einige Zwischenbilder besser aus, aber ich wollte unbedingt einen voll funktionsfähigen Algorithmus mit Voronoi-Diagrammen haben.

Bildbeschreibung hier eingeben

Bearbeiten:

Bildbeschreibung hier eingeben

Dies ist ein Beispiel für den endgültigen Algorithmus. Das Bild ist im Grunde genommen die Überlagerung von drei Voronoi-Diagrammen, eines für jede Farbkomponente (rot, grün, blau).

Code

ungolfed, kommentierte Version am Ende

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

Es hat mich sehr viel Mühe gekostet, daher möchte ich die Ergebnisse in verschiedenen Phasen teilen, und es gibt nette (falsche), die ich zeigen kann.

Erster Schritt: Einige Punkte nach dem Zufallsprinzip setzen lassen, mit x=y

Bildbeschreibung hier eingeben

Ich habe es in JPEG konvertiert, weil das ursprüngliche PNG zu schwer für das Hochladen war ( >2MB), ich wette, das sind weit mehr als 50 Graustufen!

Zweitens: Haben Sie eine bessere y-Koordinate

Ich konnte es mir nicht leisten, eine andere zufällig generierte Koordinatentabelle für die yAchse zu erstellen. Daher brauchte ich eine einfache Methode, um " zufällige " Koordinaten mit so wenigen Zeichen wie möglich zu erhalten. Ich ging für die Verwendung des xin der Tabelle von einem anderen Punkt koordinieren, um eine bitweise tut ANDauf dem Index des Punktes.

Bildbeschreibung hier eingeben

3. Ich erinnere mich nicht, aber es wird schön

Aber zu dieser Zeit war ich weit über 140 Zeichen, so dass ich es ziemlich viel Golf spielen musste.

Bildbeschreibung hier eingeben

Viertens: Scanlines

Nur ein Scherz, das ist nicht erwünscht, aber irgendwie cool.

Bildbeschreibung hier eingeben Bildbeschreibung hier eingeben

Ich arbeite immer noch an der Verkleinerung des Algorithmus und bin stolz darauf, Folgendes präsentieren zu können:

StarFox Edition

Bildbeschreibung hier eingeben

Voronoi instagram

Bildbeschreibung hier eingeben

5. Erhöhen Sie die Anzahl der Punkte

Ich habe jetzt ein funktionierendes Stück Code, gehen wir also von 25 auf 60 Punkte. Bildbeschreibung hier eingeben

Das ist auf nur einem Bild schwer zu erkennen, aber die Punkte befinden sich fast alle im selben yBereich. Natürlich habe ich die bitweise Operation nicht geändert, &42ist viel besser:

Bildbeschreibung hier eingeben

Und hier sind wir am selben Punkt wie das allererste Bild aus diesem Beitrag. Lassen Sie uns nun den Code für die seltenen erklären, die interessiert wären.

Ungolfed und erklärt Code

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

Vielen Dank fürs Lesen.

Das Internet besteht aus Catz
quelle
1
Ich liebe Voronoi-Diagramme. +1 für 3 Tweets!
Martin Ender
1
Dies ist einer meiner persönlichen Favoriten. Die Scanlinienvarianten sind ästhetisch sehr ansprechend.
Fraxtil
1
Liebe, wie Sie den Code erklärt
Andrea
Eine Drehung um die Längsachse machen!
Starson Hochschild
Das zweite Bild im vierten: Scanlines ist wunderschön.
Khaled.K
57

Das Lyapunov-Fraktal

Lyapunov Fractal

Die Zeichenfolge, die verwendet wurde, um dies zu generieren, war AABAB und der Parameterraum war [2,4] x [2,4]. ( Erklärung von String und Parameterraum hier )

Mit begrenztem Code-Platz fand ich diese Färbung ziemlich cool.

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

Ich habe auch eine Variation des Mandelbrot-Sets gemacht. Es wird eine Karte verwendet, die der Mandelbrot-Set-Karte ähnelt. Sagen Sie, M (x, y) ist die Mandelbrot-Karte. Dann ist M (sin (x), cos (y)) die Abbildung, die ich verwende, und anstatt zu prüfen, ob escape-Werte vorhanden sind, verwende ich x und y, da sie immer begrenzt sind.

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

Bildbeschreibung hier eingeben

BEARBEITEN

Nach langem Hin und Her habe ich mich endlich daran gemacht, ein GIF für das Morphing des zweiten Bildes zu erstellen. Hier ist es:

Party Zeit

Cameron
quelle
11
Netter psychedelischer Look für den zweiten.
Internet besteht aus Catz
4
Das sind verrückt ! +1
cjfaure
10
Scary Fraktal ist unheimlich
Tobia
1
Heilige Scheiße, diese Sekunde ist beängstigend. Amaximg, wie viel Sie aus dem einfachen z = z ^ 2 + c herausbekommen können.
Tomsmeding
4
Wenn Edward Munch Fraktale gemalt hätte, hätte The Scream so ausgesehen.
internet besteht aus catz
55

Weil Einhörner.

Weil Einhörner

Ich konnte die OPs-Version mit unsigned shortund Farbwerten bis 1023 nicht zum Laufen bringen. Bis dies behoben ist, ist hier eine Version mit charund einem maximalen Farbwert von 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
quelle
Ich möchte die Farbkanäle einzeln sehen. Das wäre cool.
klatschen Sie
52

Logistische Hügel

Bildbeschreibung hier eingeben

Die Funktionen

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

Ungolfed

Alle #Definitionen müssen für BL unter 140 Zeichen passen. Hier ist die ungolfed Version des blauen Algorithmus, leicht modifiziert:

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

Wo die Werte von x für ein gegebenes r (j-Wert) am häufigsten fallen, wird die Darstellung heller (normalerweise als dunkler dargestellt).

Eric Tressler
quelle
3
Oh, ich habe gestern darüber nachgedacht, wie ich das machen soll. +1, um es herauszufinden. Eigentlich finde ich die Palette echt schön wie sie ist! :)
Martin Ender
2
Ich habe die schmutzigen Tricks von dir und Githubphagozyten gestohlen, obwohl ich die Verantwortung für die hässlichen Definitionen übernehme. Besonders "#define G for (".
Eric Tressler
1
sieht eher aus wie ein Turnier Bracket Visualizer
Kevin L
3
Oben nicht abgebildet: Gewinner stirbt
Eric Tressler
1
Kann ich einen Plakatdruck davon bekommen? Mit 3 verblassten Tweets im Hintergrund. :-)
Andrew Cheong
50

Diffusionslimitierte Aggregation

Ich war schon immer fasziniert von der diffusionsbegrenzten Aggregation und der Anzahl der unterschiedlichen Erscheinungsformen in der realen Welt.

Ich fand es schwierig, dies in nur 140 Zeichen pro Funktion zu schreiben, daher musste ich den Code schrecklich machen (oder schön, wenn Sie Dinge wie ++d%=4und mögen for(n=1;n;n++)). Die drei Farbfunktionen rufen sich gegenseitig auf und definieren Makros zur gegenseitigen Verwendung, sodass sie nicht gut lesbar sind, aber jede Funktion hat knapp 140 Zeichen.

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

diffusionslimitierte Aggregation

Um zu veranschaulichen, wie sich die Partikel allmählich ansammeln, habe ich in regelmäßigen Abständen Schnappschüsse angefertigt. Jeder Frame wurde durch Ersetzen der 1 for(n=1;n;n++)durch 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29 erzeugt. 1. Dadurch wurde das Limit von 140 Zeichen für jeden Lauf knapp unterschritten.

animierte Aggregation

Sie können sehen, dass Aggregate, die nahe beieinander wachsen, sich gegenseitig die Partikel entziehen und langsamer wachsen.


Wenn Sie den Code geringfügig ändern, werden die verbleibenden Partikel angezeigt, die noch nicht an den Aggregaten haften. Dies zeigt die dichteren Regionen, in denen das Wachstum schneller erfolgt, und die sehr spärlichen Regionen zwischen Aggregaten, in denen aufgrund des Verbrauchs aller Partikel kein Wachstum mehr stattfinden kann.

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 mit sichtbaren Partikeln

Dies kann auf die gleiche Weise wie zuvor animiert werden:

animierte Aggregation mit Partikeln

Trichoplax
quelle
3
Sehr interessant, +1.
Internet besteht aus Catz
50

Spirale (genau 140)

Endprodukt

Das sind genau 140 Zeichen, wenn Sie die Funktionsüberschriften und -klammern nicht einschließen. Es ist so viel Spiralkomplexität, wie ich in die Zeichenbegrenzung einpassen könnte.

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

Nach und nach baute ich eine einfache Spirale auf, fügte Muster an den Spiralrändern hinzu und experimentierte, wie verschiedene Spiralen kombiniert werden könnten, um cool auszusehen. Hier ist eine ungolfed Version mit Kommentaren, die erklären, was jedes Stück macht. Das Spielen mit Parametern kann zu interessanten Ergebnissen führen.

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

Spielerisch mit Parametern:

Hier sind die Spiralen aneinander gereiht, haben aber unterschiedliche Kantenmuster. Anstelle der blockartigen Kanten im Hauptbeispiel weist dies Kanten auf, die vollständig aus Sinuswellen bestehen.

Kanten

Hier wurde der Farbverlauf entfernt:

kein Gefälle

Eine Animation ( die sich aus irgendeinem Grund nach dem Hochladen nicht zu wiederholen scheint. Tut mir leid. Außerdem musste ich sie verkleinern. Öffne sie einfach in einem neuen Tab, wenn du die Animation verpasst hast. ):

Animation

Und hier ist das Imgur-Album mit allen Bildern. Ich würde gerne sehen, ob jemand andere coole Spiralmuster findet. Außerdem muss ich sagen, dass dies bei weitem eine der coolsten Herausforderungen ist, die ich je gesehen habe. Genießen!

EDIT: Hier sind einige Hintergründe aus diesen Spiralen mit geänderten Parametern.

Durch Kombinieren meiner Spiralkantenmuster mit einigen der Fraktale, die ich hier durch die Verwendung von xor / und / oder Operationen gesehen habe, ist hier eine letzte Spirale:

fraktale Spirale

xleviator
quelle
2
Das sind fantastische! Wenn Sie sich in den anderen Antworten umschauen, finden Sie möglicherweise Ideen, wie Sie noch mehr Golf spielen können, wenn Sie mehr Platz möchten. Einige der Antworten verwenden #define in einer Funktion, um ein Makro zu definieren, das alle 3 verwenden können, sodass Sie den Großteil der Berechnung in andere Farbfunktionen verschieben können. Martin Büttner hat mich mit diesem Trick bekannt gemacht.
Trichoplax
Danke! In meinem Fall fehlt meinem Code, soweit ich das beurteilen kann, die Art von doppelten Logikmustern, die von Pfund-Definitionen profitieren würden. Wenn Sie jedoch welche sehen, würde ich mich freuen, wenn Sie sie für mich identifizieren würden, insbesondere, wenn ich C / C ++ seit Jahren nicht mehr ausgiebig genutzt habe.
Xleviator
Das Finden doppelter Abschnitte würde in der Tat noch mehr helfen, aber auch ohne Duplizierung können Sie Code einfach von BL nach RD oder GN verschieben, indem Sie ihn in RD oder GN als Makro definieren und dann in BL verwenden. Das sollte Ihnen doppelt so viel Platz für zusätzlichen Code geben.
Trichoplax
Ah! Aha. Ich habe nicht einmal bemerkt, dass jeder Funktionskörper selbst die maximale Zeichenanzahl von 140 aufweist. Ich nehme an, ich sollte das nächste Mal die Eingabeaufforderung genauer lesen. Vielen Dank für den Hinweis!
Xleviator
1
Wie bereits im Chat besprochen , sollte Ihr nicht durchgeschleiftes GIF leicht zu reparieren sein. Ich denke, es lohnt sich, dies zu tun, da die kurze Animation, die es derzeit zeigt, großartig aussieht.
Trichoplax
47

Hommage an einen Klassiker

V1 : Inspiriert von DreamWarriors "Be happy", bettet diese einfache Einreichung ein kleines Pixel-Art-Bild in jeden Farbkanal ein. Ich musste nicht einmal den Code spielen!
V2 : jetzt mit erheblich kürzerem Code und einem dicken schwarzen Rand, der nur den "Spielbildschirm" isoliert.
V3 : Raumschiff, Kugel, beschädigte Aliens und blaue Grenze, oh mein Gott! Der Versuch , für Ziel dieses grob.

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


Ich bin zufällig auf einen Schnitt von Umber Ferrule gestoßen, dessen Avatar mich dazu inspiriert hat, einen weiteren pixelbasierten Eintrag hinzuzufügen. Da die Kernidee des Codes weitgehend der von Space Invaders ähnelt, füge ich sie diesem Eintrag hinzu, obwohl die beiden definitiv unterschiedliche herausfordernde Punkte hatten. In diesem Fall erwies es sich als schöne Herausforderung, Pink richtig zu machen (auf Kosten von Weiß) und die Tatsache, dass es sich um ein ziemlich großes Sprite handelt. Die hexadezimalen Escapes ( \xFFusw.) im roten Kanal stellen die entsprechenden Zeichen in der Quelldatei dar (dh der rote Kanal in der Quelldatei enthält Binärdaten), während die oktalen Escapes literal sind (dh in der Quelldatei vorhanden sind).

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

FireFly
quelle
3
Ich liebe es. Viel Platz, um zusätzliche Funktionen hinzuzufügen ...
Trichoplax
1
Ja, es gibt viele Tricks, um die Größe zu reduzieren. Ich könnte versuchen, es morgen zu verlängern.
FireFly
Das ist jetzt unglaublich kurz. Könnten Sie eines dieser Bitmuster in die Textur Ihrer Raycast-Antwort einfügen ...?
Trichoplax
@ MartinBüttner hoppla, du hast recht. Ich habe es behoben und ein weiteres Update an den Funktionen vorgenommen.
FireFly
Gut, ich mag, wie Sie die 8x8-Pixel-Grafik aufgenommen und im Handumdrehen "in der Größe verändert" haben. Ich musste jedoch einige Änderungen vornehmen und erhalte immer noch nicht genau Ihr Bild. Ich änderte die 1L und 255L zu 1LL und 255LL. Da dies zu einer Verbesserung geführt hat, gehe ich davon aus, dass Sie wahrscheinlich im 64-Bit-Modus kompilieren und dass es einige Probleme mit der Bitbreite gibt, die dazu führen, dass der Rest meines Bildes falsch dargestellt wird. Trotzdem gute Arbeit!
DreamWarrior
44

Action-Malerei

Ich wollte versuchen, etwas Ähnliches wie Jackson Pollock nachzubilden - Farbe über eine horizontale Leinwand zu tropfen und zu gießen. Obwohl mir die Ergebnisse gefallen haben, war der Code viel zu lang, um auf diese Frage zu antworten, und meine besten Bemühungen haben ihn immer noch auf etwa 600 Byte reduziert. Der hier veröffentlichte Code (mit Funktionen von 139 Bytes, 140 Bytes und 140 Bytes) wurde mit enormer Hilfe einiger Genies im Chat erstellt . Vielen Dank an:

für eine unerbittliche gruppen-golfsitzung.

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}

action painting 21, 21

Das E (q) -Makro wird in den RD- und GR-Funktionen verwendet. Durch Ändern des Werts des Arguments wird die Art und Weise geändert, in der sich die roten und grünen Komponenten der Farben ändern. Das J-Makro endet mit einer Zahl, mit der bestimmt wird, wie stark sich die blaue Komponente ändert, was sich wiederum auf die rote und die grüne Komponente auswirkt, da sie daraus berechnet werden. Ich habe einige Bilder mit den roten und grünen Argumenten von E hinzugefügt, um die Vielfalt der möglichen Farbkombinationen zu zeigen. Bewegen Sie den Mauszeiger über die Bilder für die roten und grünen Werte, wenn Sie diese selbst ausführen möchten.

action painting 14, 14

action painting 63, 49

action painting 56, 42

action painting 0, 49

Alle diese Bilder können in voller Größe angezeigt werden, wenn Sie sie herunterladen. Die Dateigröße ist klein, da die flache Farbe dem PNG-Komprimierungsalgorithmus entspricht. Daher war keine verlustbehaftete Komprimierung erforderlich, um auf die Site hochzuladen.

Wenn Sie Bilder aus verschiedenen Phasen des Golfspiels sehen möchten, während wir verschiedene Dinge ausprobiert haben, können Sie im Action-Painting-Chat nachsehen .

Trichoplax
quelle
7
Ich verfolge diese Frage und alle Antworten seit ein paar Wochen, und ich muss sagen, dies ist die erste, bei der mir der Kiefer tatsächlich herunterfällt. HEILIGE ERSTAUNLICHKEIT. Ich meine, alle Antworten hier sind großartig - aber diese ist etwas, was ich nie für möglich gehalten hätte.
Todd Lehman
1
@ToddLehman danke! Dies ist sicherlich nichts, wozu ich alleine in der Lage wäre - ich weiß, weil ich versucht habe ...
Trichoplax
2
GENIAL! Eine der besten in dieser Frage und für mich die einzige (vielleicht mit Ausnahme des Gewinners), die wie von Menschen
gezeichnet
1
@cyriel vielen Dank. Man könnte sagen, dieses
Bild
43

Ich dachte, ich würde mit den Parametern dieses Codes spielen ... Das gesamte Guthaben geht an @Manuel Kasten. Diese sind einfach so cool, dass ich nicht widerstehen konnte, etwas zu posten. Heiß, kalt

/* 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
quelle
3
Sieht aus wie Dr. Seuss für mich. Sehr cool!
DLosc
3
Haha, ich habe tatsächlich die beiden unteren Dateien Seuss1 und Sueuss2 genannt
Kyle McCormick
42

Bearbeiten: Dies ist jetzt eine gültige Antwort, dank der Vorwärtserklärungen von GRund BL.

Viel Spaß mit Hofstädters Q-Sequenz! Wenn wir den radialen Abstand von einem Punkt als Eingabe und die Ausgabe als Umkehrfarbe verwenden, erhalten wir etwas, das wie farbiges Vinyl aussieht.

Bildbeschreibung hier eingeben

Die Sequenz ist der Fibonacci-Sequenz sehr ähnlich, aber anstatt 1 und 2 Schritte in der Sequenz zurückzugehen, nehmen Sie die beiden vorherigen Werte, um zu bestimmen, wie weit Sie zurückgehen müssen, bevor Sie die Summe nehmen. Es wächst ungefähr linear, aber hin und wieder kommt es (in zunehmenden Abständen) zu einem Chaosausbruch, der sich dann vor dem nächsten Ausbruch wieder in einer fast linearen Reihenfolge niederschlägt:

Bildbeschreibung hier eingeben

Sie können diese Wellen im Bild nach Regionen sehen, die in der Farbe sehr "flach" aussehen.

Nur eine Farbe zu verwenden ist natürlich langweilig.

Bildbeschreibung hier eingeben

Nun zum Code. Ich brauche die rekursive Funktion, um die Sequenz zu berechnen. Dazu benutze ich RDwann immer jes negativ ist. Leider, das nicht verlassen genug Zeichen Rotkanalwert selbst zu berechnen, so RDruft wiederum GRmit einem den roten Kanal zu erzeugen , versetzt.

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

Dies ist natürlich so ziemlich die einfachste Verwendung der Sequenz, und es sind noch viele Zeichen übrig. Fühlen Sie sich frei, es auszuleihen und andere verrückte Dinge damit zu tun!

Hier ist eine andere Version, bei der die Grenze und die Farben durch die Q-Sequenz bestimmt werden. In diesem Fall war genügend Platz, RDso dass ich nicht einmal die Forward-Deklaration brauchte:

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

Bildbeschreibung hier eingeben

Martin Ender
quelle
1
Das zweite graue Bild ist atemberaubend!
Tomsmeding
Können Sie dies ausreichend komprimieren, um die Funktionen r / g / b selbst rekursiv mit ungültigen Koordinaten für die rekursiven Aufrufe zu verwenden?
Sparr
Ich habe das mehrfarbige Bild geliebt. Gute Antwort!
Alex
41

Dies berechnet die Joukowsky-Transformation eines Satzes konzentrischer Kreise, die auf einem Punkt zentriert sind, der geringfügig vom Ursprung versetzt ist. Ich habe die Intensitäten im blauen Kanal leicht verändert, um ein wenig Farbabweichung zu erzielen.

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

Bildbeschreibung hier eingeben

zimperliches Ossifrage
quelle
39

Ziel c

Den C ++ - Code in Objective-C umgeschrieben, da ich ihn nicht kompilieren konnte ... Es gab die gleichen Ergebnisse wie andere Antworten, wenn es auf meinem iPad ausgeführt wurde, das ist also alles gut.

Hier ist mein Beitrag:

Dreiecke in Hülle und Fülle

Der Code dahinter ist ziemlich einfach:

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

Sie können in auf Plätzen vergrößern durch Multiplikation iund jdurch 0.5, 0.25usw. , bevor sie verarbeitet werden.

Max Chuquimia
quelle
Sind Sie sicher, dass dies derselbe Code ist, den Sie verwendet haben? Das ^ sieht irgendwie seltsam aus, weil (i ^ i) immer 0 (das XOR) ist und das ^ 2 eher wie ein Quadrat als wie ein XOR-Bit aussieht.
Manuel Ferreria
1
@ManuelFerreria Mit dem XOR wird der Code tatsächlich so kompiliert: x^(x-y)^y(Das hat mich auch das erste Mal fertig gemacht). Wenn Sie iOS-Funktionen haben, finden Sie hier meinen Code: gist.github.com/Jugale/28df46f87037d81d2a8f
Max Chuquimia
38

Sierpinski Paint Splash

Ich wollte mehr mit Farben spielen, also änderte ich meine andere Antwort (die wirbelnde) und endete schließlich damit.

Sierpinski Paint Splash

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

Es ist jetzt mein Avatar. : P

cjfaure
quelle
4
Gut gemacht. Herr, gute Arbeit.
EaterOfCode
37

Ich fühle mich gezwungen, diesen Eintrag einzureichen, den ich als "undefiniertes Verhalten" bezeichne. Dies zeigt, was Ihr Compiler mit Funktionen macht, die einen Wert zurückgeben sollen, dies aber nicht tun:

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

Alle schwarzen Pixel:

alle schwarzen Pixel

Pseudozufällige Pixel:

pseudozufällige Pixel

Und natürlich eine Vielzahl weiterer möglicher Ergebnisse, abhängig von Ihrem Compiler, Computer, Speichermanager usw.

Sparr
quelle
3
Welches hast du bekommen?
Tomsmeding
3
Ich habe ein durchgehendes Schwarz und eine durchgehende Farbe erhalten, die sich zwischen verschiedenen Programmläufen mit verschiedenen Compilern geändert hat.
Sparr
8
Mein Compiler macht nur Fehler und schreit mich an, weil ich keinen Wert zurückgebe.
Pharap
3
@Pharap, das ist keine schlechte Sache :)
Sparr
Ich bezweifle, dass Sie jemals so eine nette Zufälligkeit bekommen würden, wie es Ihr zweites Bild nahe legt. Ein konstanter Wert, der Index der Schleife usw. sind viel wahrscheinlicher (was auch immer in EAX gespeichert ist, wenn die Funktion aufgerufen wird).
Beispiel
37

groovig

groovy.png

Nur ein paar Trigonometrie und seltsame Makrotricks.

RD:

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

GR:

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

BL:

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

BEARBEITEN: Wenn dies M_PInicht zulässig ist, weil es nur auf POSIX-kompatiblen Systemen vorhanden ist, kann es durch das Literal ersetzt werden 3.14.

Fraxtil
quelle
1
Ich habe freie Charaktere, acos(-1)ist ein guter Ersatz für M_PI.
Martin Ender
33

Ich kann nicht gut rechnen. Ich war immer ein schlechter Schüler im Matheunterricht. Also habe ich einfach eins gemacht.

mathpic1.png

Ich habe modifiziert Javascript-Code von user1455003 verwendet . Und das ist mein vollständiger Code .

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

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

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

Es ist sehr kurz, sodass alle drei Funktionen in einen Tweet passen.


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

Eine weitere sehr kurze Funktionen. Ich habe dieses Sierpinski-Muster (und einige Tangentenmuster) gefunden, als ich mit verschiedenen mathematischen Funktionen rumgespielt habe.Dies ist der vollständige Code

Snack
quelle
i&jRendert einfach das Sierpinski-Dreieck. Welches ist genial .
cjfaure
Das letzte ist Profilbild-würdig.
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;
}

Vereinigte Staaten von Amerika

Andere Version. Funktionskörper sind tweetbar.

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

Bildbeschreibung hier eingeben

Überarbeitete Bildrenderfunktion. 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)
}

Lila

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

Bildbeschreibung hier eingeben

Wolfhammer
quelle
BETRÜGER! BETRÜGER! ; D (es ist eine gültige Antwort, einfach zu klug: P Schöne!)
Tomsmeding
1
Hahah ... ja, ich weiß, also habe ich eine eingereicht, die mehr im Sinne der Frage ist. Ich habe tatsächlich versucht, Muster zu erstellen und dachte, ich frage mich, ob ich wirklich etwas zeichnen könnte.
Wolfhammer
Sie können die flachen Farbbilder ein wenig fetter wirken lassen, indem Sie in den unteren Bits ein Filmrauschen hinzufügen, indem Sie am Ende ein "| Math.random () * 256" anbringen. Lässt die dunkleren Schattierungen zufälliger werden, ohne die Glanzlichter zu verändern. (und erhöhen Sie die Zahl in Abhängigkeit von der Dunkelheitsschwelle)
Kent Fredric
rgb randomness @ [10,728,728] i.imgur.com/ms4Cuzo.png
Kent Fredric
31

Planetenmaler

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

Inspiriert von Martins offensichtlich großartigem Beitrag , ist dies eine andere Einstellung dazu. Anstatt einen Teil der Pixel zufällig auszusondern, beginne ich mit der linken oberen Ecke als RGB (512.512.512) und gehe von dort aus auf jeder Farbe zufällig spazieren. Das Ergebnis sieht aus wie ein Teleskop (imo).

Jedes Pixel nimmt den Durchschnitt der darüber / links liegenden Pixel und fügt ein bisschen Zufall hinzu. Sie können mit der Variabilität spielen, indem Sie die pVariable ändern , aber ich denke, ich verwende eine gute Balance (hauptsächlich, weil ich blau mag, damit mehr Unschärfevolatilität gute Ergebnisse liefert).

Bei der Mittelwertbildung kommt es zu einer leichten negativen Verzerrung durch die Ganzzahldivision. Ich denke, es funktioniert jedoch und gibt der unteren Ecke einen schönen Verdunkelungseffekt.

Natürlich müssen Sie srand()Ihrer Hauptfunktion eine Zeile hinzufügen, um mehr als nur ein einziges Ergebnis zu erhalten .

Bands

Geobits
quelle
2
Wenn das Bild etwas größer wäre, würde es wie Lichtstrahlen aussehen. o:
cjfaure
1
@cjfaure Wenn Sie das Bild in voller Größe anzeigen (herunterladen / Rechtsklick und Bild anzeigen / was auch immer auf Ihrem System funktioniert), dann sieht es mit den zusätzlichen Details noch schöner aus.
Trichoplax
mache es zu einem Kreis, der von Schwarz umgeben ist, und das macht es zu einem Planeten!
Khaled.K
1
Ich habe versucht, dies mit einem Mixer um eine Kugel zu wickeln und habe eine Animation gerendert. Siehe hier: gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs
30

Reflektierte Wellen

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

Ein grundlegendes Schachbrettmuster, das entsprechend der Position einer Welle verzerrt ist, die sich von einem Punkt aus aus ausdehnt, wie ein Stein, der in einen Teich gefallen ist (sehr weit von der physischen Genauigkeit entfernt!). Die Variable wist die Anzahl der Pixel von dem Punkt an, an dem sich die Welle bewegt hat. Wenn wes groß genug ist, wird die Welle von den Seiten des Bildes reflektiert.

w = 225

Wellen mit w = 225

w = 360

Wellen mit w = 360

w = 5390

Wellen mit w = 5390

Hier ist ein GIF, das eine Folge von Bildern zeigt, wenn sich die Welle ausdehnt. Ich habe eine Reihe verschiedener Größen angegeben, von denen jede so viele Frames anzeigt, wie es die maximale Dateigröße von 500 KB zulässt.

Wellen große GIF

Wellen kleine GIF Wellen mittel GIF


Wenn ich einen Weg finden kann, wie ich ihn einpassen kann, möchte ich im Idealfall eine Welleninterferenz modellieren, damit die Wellen realistischer aussehen, wenn sie sich kreuzen. Ich bin jedoch mit dem Nachdenken zufrieden.

Beachten Sie, dass ich die Wellenreflexion in 3 Lots von 140 Bytes nicht wirklich modelliert habe. Es wird nicht wirklich darüber nachgedacht, es sieht einfach so aus. Ich habe die Erklärung ausgeblendet, falls jemand zuerst raten möchte:

Die erste reflektierte Welle ist identisch mit einer Welle, die von der anderen Seite der Bildkante ausgeht und denselben Abstand wie der ursprüngliche Punkt hat. Der Code berechnet also die richtige Position für die 4 Punkte, die erforderlich sind, um den Reflexionseffekt von jeder der 4 Kanten zu erzielen. Weitere Ebenen der reflektierten Welle sind alle mit einer Welle identisch, die aus einer weiteren entfernten Kachel stammt, wenn Sie sich das Bild als eine Kachel in einer Ebene vorstellen. Der Code gibt die Illusion von 8 Reflexionsebenen, indem 189 separate expandierende Kreise angezeigt werden, die jeweils an der richtigen Stelle in einem 17 x 17-Raster platziert sind, sodass sie durch das zentrale Quadrat des Rasters (dh das Bildquadrat) bei gehen genau die richtigen Zeiten, um einen Eindruck von der geforderten aktuellen Reflexionsstärke zu bekommen. Das ist einfach (und kurz!) Zu programmieren, läuft aber ziemlich langsam ...

Trichoplax
quelle
3
Lieben Sie die GIFs und die Erklärung.
DLosc
Neato! Aber man, Einträge wie diese lassen mich denken, ich brauche einen schnelleren Computer (oder mehr Geduld, lol). Entweder ist Ihr Computer viel schneller, oder ich möchte nicht darüber nachdenken, wie lange Sie für die Erstellung all dieser GIF-Frames gebraucht haben.
DreamWarrior
3
@DreamWarrior Ich bin es nicht, der Geduld hat. Es ist mein Laptop, der nichts dagegen hat, über Nacht zu laufen, während ich schlafe ...
Trichoplax
2
Ich sehe Pacman im zweiten Bild.
AL