Art mathématique tweetable [fermé]

330

Les mathématiques entières peuvent générer des motifs étonnants lorsqu'elles sont disposées sur une grille. Même les fonctions les plus élémentaires peuvent donner des designs incroyablement élaborés!

Votre challenge

Ecrivez 3 corps de fonction tweetable (c'est-à-dire 140 caractères ou moins) pour les valeurs rouge, verte et bleue pour une image 1024x1024.

Les entrées des fonctions seront deux entiers i (numéro de colonne pour le pixel donné) et j (numéro de ligne pour le pixel donné) et la sortie sera un court-circuit non signé compris entre 0 et 1023 inclus, ce qui représente le montant de la valeur donnée. couleur présente dans le pixel (i, j).

Par exemple, les trois fonctions suivantes produisent l'image ci-dessous:

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

Modèle 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;

Modèle 2

Les règles

  • Étant donné ce code C ++ , remplacez-le dans vos fonctions. J'ai fourni quelques macros et inclus la bibliothèque, et vous pouvez inclure complex.h. Vous pouvez utiliser toutes les fonctions de ces bibliothèques et / ou de mes macros. Veuillez ne pas utiliser de ressources externes au-delà de cela.
  • Si cette version ne fonctionne pas pour vous, assurez-vous de compiler avec:

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

    Si cela ne fonctionne pas, veuillez utiliser la version alternative en utilisant des caractères non signés au lieu de courts non signés.

Michaelangelo a fourni une version de sortie couleur nettoyée 24 bits ou 48 bits .

  • Vous pouvez implémenter votre propre version dans un autre langage, mais celle-ci doit se comporter de la même manière que la version C ++ fournie. Seules les fonctions des éléments intégrés de C ++, de la bibliothèque ou des macros fournies peuvent être utilisées pour la rendre juste.
  • Publiez uniquement vos trois corps de fonction - veuillez ne pas inclure mon code dans votre message
  • Veuillez inclure une version plus petite ou une copie intégrée de votre image. Ils sont convertis au format ppm et doivent éventuellement être convertis en un autre format pour une visualisation correcte sur stackexchange.
  • Les corps de fonction (signature non comprise) doivent comporter 140 caractères au maximum.
  • Ceci est un concours de popularité - la plupart des votes sont gagnants
Kyle McCormick
la source
3
Ajout d'une balise C ++ car la nature des règles exclut les autres langues. Nous préférons généralement les défis agnostiques à la langue, à moins qu'ils aient une bonne raison d'exiger un ensemble spécifique.
algorithmshark
4
Essayez de rédiger une réponse à cette question en premier lieu aux électeurs serrés qui appellent cela trop large. C'est étonnamment restrictif ...
trichoplax
8
C'est mon truc préféré que j'ai vu ici à jamais!
David Conrad
4
J'aime que cette question ressemble à une scène de démonstration de la vieille école.
mskfisher
23
Ce type de question encourage la participation au code golf . Je ne suis généralement pas enclin à répondre à une question de golf simple, car je ne suis pas sûr de bien réussir. Avec ce type de question, la limite d'octets me fait essayer une réponse simple, apprendre des techniques de golf en cours de route, puis les utiliser pour apporter des réponses plus complexes. C'est comme un tremplin pour répondre aux questions de golf. Je pense que cela pourrait être la clé pour attirer plus de gens.
trichoplax

Réponses:

120

Mandelbrot 3 x 133 caractères

La première chose qui me vint à l'esprit fut "Mandelbrot!".

Oui, je sais qu'il y a déjà une soumission de mandelbrot. Après avoir confirmé que je pouvais le faire moi-même en-dessous de 140 caractères, j'ai pris les astuces et optimisations de cette solution dans la mienne (merci à Martin et Todd). Cela laissait de la place pour choisir un emplacement et un zoom intéressants, ainsi qu’un joli thème de couleur:

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 caractères au total

J'ai essayé de le réduire à 140 pour les 3 canaux. Il y a un peu de bruit de couleur près du bord, et l'emplacement n'est pas aussi intéressant que le premier, mais: 132 caractères

mandelbrot-réduit

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
la source
8
Ces couleurs sont magnifiques!
Martin Ender
J'adore celui-ci, la meilleure image à ce jour!
Roy van Rijn
4
Ceci est mon fond d'écran maintenant.
Chiffre
209

Nappes

Plat

J'ai commencé par mettre en perspective un motif à carreaux / vichy comme une nappe sans limite:

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

nappe plate

Ondulation

Ensuite, j'ai introduit une ondulation (perspective non strictement correcte, mais toujours en 140 caractères):

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

nappe ondulée

Couleur

Ensuite, j'ai rendu certaines couleurs plus fines pour donner des détails sur une gamme plus large d’échelles et pour rendre la photo plus colorée ...

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

nappe de couleur

En mouvement

Réduire légèrement le code permet de définir une phase d'onde P avec 2 décimales, ce qui suffit pour des images suffisamment proches pour une animation fluide. À ce stade, j’ai réduit l’amplitude afin d’éviter le mal de mer et redéfini l’ensemble de l’image de 151 pixels supplémentaires (au prix d’un caractère supplémentaire) afin de faire disparaître le repliement du spectre. Le crénelage animé est hypnotique.

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

nappe animée

trichoplax
la source
15
C'est légendaire. (Y) Continuez comme ça. : P
Mohammad Areeb Siddiqui
Mais comment exactement le mouvement est mis en œuvre? Dans le cadre d'origine, il n'y a pas de logique de changement de cadre, n'est-ce pas?
esteewhy
2
@esteewhy seules des images fixes peuvent être produites. Le format GIF montre une séquence d'images fixes, chacune ayant été produite en modifiant la valeur après #define P. Il fallait jouer au golf pour permettre les personnages supplémentaires #define P 6.03.
Trichoplax
4
ARRÊTEZ! Souhaitez-vous vraiment augmenter la première réponse? Il en existe d’autres beaucoup plus intéressantes si vous faites défiler les deux pages suivantes.
Trichoplax
1
Je recommande de trier les réponses par "plus ancien" et vous pourrez ensuite voir comment de nouvelles approches ont été développées à mesure que de nouvelles réponses entraient.
trichoplax
192

Peintre au hasard

entrez la description de l'image ici

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

Voici une entrée basée sur le hasard. Pour environ 0,1% des pixels, il choisit une couleur aléatoire, pour les autres, il utilise la même couleur qu'un pixel adjacent aléatoire. Notez que chaque couleur le fait de manière indépendante. Il ne s’agit donc que d’une superposition d’images aléatoires de couleur verte, bleue et rouge. Pour obtenir des résultats différents sur différentes exécutions, vous devez ajouter srand(time(NULL))à la mainfonction.

Maintenant, pour quelques variations.

En sautant des pixels, nous pouvons le rendre un peu plus flou.

entrez la description de l'image ici

Et puis, nous pouvons changer lentement les couleurs, où les débordements se traduisent par des changements brusques qui font que cela ressemble encore plus à des coups de pinceau.

entrez la description de l'image ici

Les choses que j'ai besoin de comprendre:

  • Pour une raison quelconque, je ne peux pas mettre sranddans ces fonctions sans obtenir une erreur de segmentation.
  • Si je pouvais rendre les marches aléatoires identiques sur les trois couleurs, cela pourrait sembler un peu plus ordonné.

Vous pouvez également rendre la marche aléatoire isotrope, comme

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

pour te donner

entrez la description de l'image ici

Plus de peintures aléatoires

J'ai joué un peu plus avec cela et créé d'autres peintures aléatoires. Tous ne sont pas possibles dans les limites de ce défi, je ne souhaite donc pas les inclure ici. Mais vous pouvez les voir dans cette galerie imgur avec quelques descriptions de la façon dont je les ai produites.

Je suis tenté de développer toutes ces possibilités dans un cadre et de le mettre sur GitHub. (Ce genre de choses n'existe pas déjà, mais c'est amusant quand même!)

Martin Ender
la source
12
Je les adore. Je n'avais pas réalisé qu'il serait possible de prendre en compte les pixels adjacents sans avoir accès aux données de pixel - tout va bien!
Trichoplax
1
Cela me rappelle beaucoup de ce vieux concours où les règles étaient de mettre un pixel de chaque couleur dans l'image.
internets est faite de chat
2
Hou la la! Ces photos sont absolument magnifiques!
raptortech97
1
Galerie cool, les radiales sont bien.
internet est fait de chatz
2
Je vois Reptar : dernière image du message (isotrope), quadrant supérieur droit.
Tim Pederick
162

Certaines choses swirly pointy

Oui, je savais exactement comment l'appeler.

Certaines choses swirly pointy

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

EDIT: n'utilise plus pow. EDIT 2: @PhiNotPi a fait remarquer que je n'ai pas besoin d'utiliser autant d'abs.

Vous pouvez changer les points de référence assez facilement pour obtenir une image différente:

Quelques choses plus swirly pointy

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 a souligné que Batman était dans mes images.

Homme chauve-souris

cjfaure
la source
1
@JayKominek Je ne sais pas, je n'étais pas là à l'époque d:
cjfaure
2
@JayKominek je l'ai trouvé. web.archive.org/web/19990221092445/http://www.blorf.com/…
cjfaure
1
@ cjfaure oh wow! Merci! il semble que la version finale de la description se trouve à l' adresse suivante : web.archive.org/web/20031205062033/http://www.blorf.com/~mrad/… et que le code a été déplacé vers sourceforge. mis à jour l'année dernière même! sourceforge.net/projects/libswirlies
Jay Kominek
1
Un de mes favoris!
Hobbies de Calvin le
1
Celui-ci est joli - mais je ne peux pas le reproduire du tout! Le plus proche que je puisse obtenir est lorsque le PPM est généré de manière incorrecte (LSB au lieu de MSB) et même alors, il ressemble à une variété de cercles alpha-mélangés de couleurs différentes.
DreamWarrior
123

Bien sûr, il doit y avoir une soumission de Mandelbrot.

entrez la description de l'image ici

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

Essayer d'améliorer le jeu de couleurs maintenant. Est-ce une erreur si je définis le calcul comme une macro red_fnet que je l' utilise dans les deux autres, de sorte que j'ai plus de caractères pour la sélection de couleurs fantaisie en vert et en bleu?

Edit: Il est très difficile de trouver des schémas de couleurs corrects avec ces quelques octets restants. Voici une autre version:

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

entrez la description de l'image ici

Et selon la suggestion de githubphagocyte et les améliorations de Todd Lehman, nous pouvons facilement choisir des sections plus petites:

Par exemple

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

donne

entrez la description de l'image ici

Martin Ender
la source
12
@ tomsmeding Je dois avouer que c'est la première fois que j'implémente l'ensemble de Mandelbrot.
Martin Ender
2
Aussi emblématique que soit l'ensemble complet de Mandelbrot (+1, en passant!), Il semble que vous ayez laissé vous-même juste assez de place pour ajuster les paramètres et poster une réponse avec quelques-uns des détails étonnamment tordus d'un zoom profond.
Trichoplax
1
@githubphagocyte J'y ai déjà pensé, mais je n'ai pas encore eu la peine de recompiler, de réexécuter et de convertir à chaque fois jusqu'à ce que je sache quels sont les paramètres corrects;). Peut-être le faire plus tard. Je dois d’abord essayer une fonction complètement différente. ;)
Martin Ender
2
@githubphagocyte a finalement réussi à ajouter cela. Merci pour la suggestion!
Martin Ender
2
Merci @ Todd, j'ai mis à jour la photo finale avec cela. J'ai utilisé 25600 itérations, cela trop longtemps. ;)
Martin Ender
110

Julia définit

S'il y a un Mandelbrot, il devrait y avoir aussi un set Julia.

entrez la description de l'image ici

Vous pouvez passer des heures à peaufiner les paramètres et les fonctions, ce qui en fait un modèle rapide et élégant.

Inspiré de la participation de Martin.

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

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

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

Voulez-vous du RNG?

OK, le commentaire de Sparr m'a mis sur la piste pour randomiser les paramètres de ce petit Julias. J'ai d'abord essayé de faire du piratage au niveau des bits avec le résultat de, time(0)mais le C ++ n'autorisant pas les littératures hexadécimales à virgule flottante, il s'agissait donc d'une impasse (du moins, à ma connaissance,). J'aurais pu utiliser des castings lourds pour y parvenir, mais cela n'aurait pas été compris dans les 140 octets.

De toute façon, il ne me restait plus beaucoup de place, alors j’ai dû laisser tomber la Julia rouge pour pouvoir mettre mes macros et disposer d’un RNG plus conventionnel ( timegraine d et réelle rand(), woohoo!).

entrez la description de l'image ici

Oups, il manque quelque chose. Évidemment, ces paramètres doivent être statiques ou vous aurez des résultats étranges (mais drôle, peut-être que je vais étudier un peu plus tard si je trouve quelque chose d’intéressant).

Nous y sommes donc, avec uniquement les canaux vert et bleu:

entrez la description de l'image ici

entrez la description de l'image ici

entrez la description de l'image ici

Ajoutons maintenant un motif rouge simple pour combler le vide. Pas vraiment imaginatif, mais je ne suis pas un programmeur graphique ... pour le moment :-)

entrez la description de l'image ici

entrez la description de l'image ici

Et enfin le nouveau code avec des paramètres aléatoires:

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

Il y a encore de la place maintenant ...

l'internet est fait de chat
la source
avez-vous de la place pour randomiser les paramètres de chaque exécution avec srand (heure (0) et rand ()? ou juste l'heure (0)?)
Sparr
2
Ce dernier est sur mon mur.
cjfaure
@Sparr mis à jour avec votre suggestion. Eu du plaisir :-).
internets est fait de chatz
4
Je ne peux pas vous dire à quoi ressemble le plus: votre réponse ou votre nom d'utilisateur
William Barbosa
107

Celui-ci est intéressant car il n'utilise pas du tout les paramètres i, j. Au lieu de cela, il se souvient de l'état d'une variable statique.

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

coloré

Manuel Kasten
la source
Il serait intéressant de voir les résultats de ce code sur différentes plates-formes / compilateurs. La valeur de RAND_MAX varie beaucoup et peut donner des images complètement différentes ...
trichoplax
5
Cela ne devrait pas beaucoup changer. (double) rand () / RAND_MAX devrait toujours être dans la plage [0.0, 1.0].
Manuel Kasten
2
C'est l'un de mes favoris!
Hobbies de Calvin le
2
Ce n'est pas seulement intéressant, c'est beau!
Martin Thoma
104

Image

/* 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
la source
3
C'est vraiment beau, +1.
Milo
3
C'est mon préféré. Cela ressemble à une pièce de graphisme professionnel. : D
cjfaure
4
Cela ressemble à une plaquette de microprocesseurs. macrophotographer.net/images/ss_rvsi_5.jpg
jeudi 08
Cela ressemble à un papier peint minimaliste .
AL
1
Cela ressemble au logo arc -en -pomme .
LegionMammal978
82

Buddhabrot (+ Antibuddhabrot)

Edit: C'est un véritable Buddhabrot maintenant!

Edit: j'ai réussi à limiter l'intensité de la couleur dans la limite d'octet, de sorte qu'il n'y ait plus de pixels faussement noirs en raison du débordement.

Je voulais vraiment m'arrêter après quatre heures ... mais ...

entrez la description de l'image ici

Ceci est légèrement compressé pendant le téléchargement (et réduit lors de l'intégration), donc si vous voulez admirer tous les détails, voici l'intéressant recadrage 512x512 (qui n'est pas compressé et est affiché dans sa taille réelle):

entrez la description de l'image ici

Merci à githubphagocyte pour l'idée. Cela nécessitait un abus assez compliqué des trois fonctions de couleur:

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

Il reste quelques octets pour un meilleur jeu de couleurs, mais jusqu'à présent, je n'ai rien trouvé qui vaille mieux que l'image en niveaux de gris.

Le code, tel qu'il est donné, utilise 4096 x 4096 points de départ et effectue jusqu'à 500 000 itérations sur chacune d'elles pour déterminer si les trajectoires s'échappent ou non. Cela a pris entre 6 et 7 heures sur ma machine. Vous pouvez obtenir des résultats corrects avec une grille de 2k par 2k et 10k itérations, ce qui prend deux minutes, et même une grille de 1k par 1k avec 1k itérations est très jolie (cela prend environ 3 secondes). Si vous souhaitez modifier ces paramètres, vous devez modifier quelques éléments:

  • Pour modifier la profondeur de récursion de Mandelbrot, ajustez les deux instances de 5e5dans BLvotre nombre d'itérations.
  • Pour modifier la résolution de la grille, changer tous les quatre 4096dans RDla résolution désirée et 1024.dans GRle même facteur pour maintenir la mise à l' échelle correcte.
  • Vous aurez probablement aussi besoin de redimensionner l' return c[i][j]in dans la GRmesure où cela contient uniquement le nombre absolu de visites de chaque pixel. La couleur maximale semble être la plupart du temps indépendante du nombre d'itérations et évolue linéairement avec le nombre total de points de départ. Donc, si vous voulez utiliser une grille de 1k sur 1k, vous pouvez le faire return c[i][j]*16;ou similaire, mais ce facteur nécessite parfois quelques manipulations.

Pour ceux qui ne connaissent pas Buddhabrot (comme moi il y a quelques jours), il est basé sur le calcul de Mandelbrot, mais l'intensité de chaque pixel correspond à la fréquence de visite de ce pixel dans les itérations des trajectoires d'échappement. Si nous comptons les visites lors de trajectoires non échappées, c'est un Antibuddhabrot. Il existe une version encore plus sophistiquée appelée Nebulabrot dans laquelle vous utilisez une profondeur de récursivité différente pour chaque canal de couleur. Mais je laisserai cela à quelqu'un d'autre. Pour plus d' informations, comme toujours, Wikipedia .

À l'origine, je ne faisais pas la distinction entre les trajectoires d'échappement et les trajectoires sans fuite. Cela a généré un complot qui est l'union d'un Buddhabrot et d'un Antibuddhabrot (comme indiqué par 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;
}

entrez la description de l'image ici

Celui-ci ressemble un peu à une photo fanée ... J'aime ça.

Martin Ender
la source
8
Je vais en faire un chapeau.
cjfaure
6
Je suis vraiment étonné que vous ayez réduit cela à 3 lots de 140 octets. La nouvelle image de buddabrot est magnifique.
Trichoplax
4
C'est vraiment impressionnant.
Copumpkin
Le premier est vraiment astucieux. Ça me rappelle les méduses. +1
Igby Largeman
1
Celui-ci est ma soumission préférée. Bon travail!
thomallen
76

Sierpinski Pentagon

Vous avez peut-être vu la méthode du jeu du chaos consistant à approximer le triangle de Sierpinski en traçant des points à mi-chemin d'un sommet choisi au hasard. Ici, j'ai adopté la même approche en utilisant 5 sommets. Le code le plus court sur lequel je pouvais me résoudre incluait le codage en dur des 5 sommets, et il n’était pas question pour moi d’adapter tout cela à 140 caractères. J'ai donc délégué le composant rouge à un fond simple et utilisé l'espace disponible dans la fonction rouge pour définir une macro afin de ramener les deux autres fonctions à moins de 140 également. Donc, tout est valable au prix de ne pas avoir de composant rouge dans le pentagone.

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

Merci à Martin Büttner pour l’idée mentionnée dans les commentaires de la question sur la définition d’une macro dans une fonction à utiliser ensuite dans une autre, ainsi que pour l’utilisation de la mémoire pour remplir les pixels dans un ordre arbitraire plutôt que de se limiter à l’ordre de trame de la fonction principale .

Pentagone

L'image dépasse 500 Ko. Elle est donc automatiquement convertie en jpg par échange de pile. Cela brouille certains des détails les plus fins. J'ai donc également inclus le quart supérieur droit sous forme de png pour montrer le look original:

en haut à droite

trichoplax
la source
73

Partition

Sierpinski musique. : D Les gars sur le chat disent qu'il ressemble plus au papier perforé pour les boîtes à musique.

Partition

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

Quelques détails sur la façon dont cela fonctionne ... euh, il ne s'agit en fait que d'un zoom avant sur le rendu de certains triangles de Sierpinski ondulés. L'aspect de la partition (et son aspect bloc) est le résultat d'une troncature d'entier. Si je change la fonction rouge à, par exemple,

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

la troncature est supprimée et nous obtenons le rendu en pleine résolution:

Partitions non bloquantes

Alors oui, c'est intéressant.

cjfaure
la source
1
C'est comme Squarepusher transcrit en neumes
ossifrage délirant
1
@squeamishossifrage Qu'est-ce que je viens de regarder ...?
cjfaure
:-) Les vidéos de Chris Cunningham sont un peu étranges, n'est-ce pas?
ossifrage
14
le deuxième semble bouger quand je fais défiler la page
user13267
5
En parcourant le site, le dernier semblait vraiment bouger. Belle illusion d'optique.
Kyle Kanos
61

Quelqu'un at-il un générateur de diagramme aléatoire de Voronoï ?

OK, celui-ci m'a donné du fil à retordre. Je pense que c’est plutôt bien, même si les résultats ne sont pas aussi artistiques que d’autres. C'est l'affaire avec le hasard. Certaines images intermédiaires semblent peut-être meilleures, mais je voulais vraiment avoir un algorithme pleinement fonctionnel avec des diagrammes de voronoï.

entrez la description de l'image ici

Modifier:

entrez la description de l'image ici

Ceci est un exemple de l'algorithme final. L'image est fondamentalement la superposition de trois diagrammes de voronoï, un pour chaque composante de couleur (rouge, vert, bleu).

Code

non golfé, version commentée à la fin

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

Il m'a fallu beaucoup d'efforts, alors j'ai envie de partager les résultats à différentes étapes, et il y en a de bonnes (incorrectes) à montrer.

Première étape: placer quelques points au hasard, avec x=y

entrez la description de l'image ici

Je l'ai converti en jpeg parce que le png original était trop lourd pour upload ( >2MB), je parie que c'est bien plus de 50 nuances de gris!

Deuxièmement: avoir une meilleure coordonnée y

Je ne pouvais pas se permettre d'avoir une autre table de coordonnées générées au hasard pour l' yaxe, donc je besoin d' un moyen simple d'obtenir « au hasard » les dans le moins de caractères possible. Je suis allé en utilisant les xcoordonnées d'un autre point de la table, en faisant un bitwise ANDsur l'index du point.

entrez la description de l'image ici

3ème: je ne m'en souviens pas mais ça commence à bien

Mais à cette époque, j’avais dépassé les 140 personnages, j’avais donc besoin de beaucoup jouer au golf.

entrez la description de l'image ici

4ème: lignes de balayage

Je plaisante, ce n'est pas voulu, mais plutôt cool, il me semble.

entrez la description de l'image ici entrez la description de l'image ici

Toujours en train de réduire la taille de l'algorithme, je suis fier de présenter:

Édition StarFox

entrez la description de l'image ici

Voronoï instagram

entrez la description de l'image ici

5ème: augmenter le nombre de points

J'ai maintenant un morceau de code de travail, passons donc de 25 à 60 points. entrez la description de l'image ici

C'est difficile à voir à partir d'une seule image, mais les points sont presque tous situés dans la même yplage. Bien sûr, je n'ai pas changé l'opération bitwise, &42c'est bien mieux:

entrez la description de l'image ici

Et nous sommes au même point que la toute première image de ce post. Expliquons maintenant le code pour les rares qui seraient intéressés.

Ungolfed et expliqué le 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];
}

Merci d'avoir lu jusqu'ici.

l'internet est fait de chat
la source
1
J'aime les diagrammes de Voronoï. +1 pour l'ajuster dans 3 tweets!
Martin Ender
1
C'est l'un de mes favoris personnels. Les variantes de lignes de balayage sont très esthétiques.
Fraxtil
1
J'adore la façon dont vous avez expliqué le code
Andrea
Faire un tonneau!
Starson Hochschild
la deuxième photo en 4ème: scanlines est magnifique.
Khaled.K
57

La fractale de Lyapunov

Fractal de Lyapunov

La chaîne utilisée pour générer ceci était AABAB et l'espace de paramètre était [2,4] x [2,4]. ( explication de la chaîne et de l'espace de paramètre ici )

Avec un espace de code limité, je pensais que cette coloration était plutôt 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);

J'ai également fait une variante de l'ensemble Mandelbrot. Il utilise une carte similaire à celle de Mandelbrot. Dites M (x, y) est la carte de Mandelbrot. Alors M (sin (x), cos (y)) est la carte que j’utilise, et au lieu de rechercher les valeurs qui échappent, j’utilise x, et y car elles sont toujours délimitées.

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

entrez la description de l'image ici

MODIFIER

Après beaucoup de douleur, j'ai finalement réussi à créer un gif de la deuxième image en train de se transformer. C'est ici:

L'heure de la fête

Cameron
la source
11
Beau look psychédélique pour le second.
internets est faite de chat
4
Ils sont fous ! +1
cjfaure
10
La fractale effrayante fait peur.
Tobia
1
Putain de merde cette seconde est effrayante. Amaximg combien vous pouvez obtenir du simple z = z ^ 2 + c.
tomsmeding
4
Si Edward Munch avait l'habitude de peindre des fractales, cela aurait ressemblé à The Scream .
internets sont fabriqués en catz
55

Parce que les licornes.

Parce que les licornes

Je ne pouvais pas utiliser la version OP avec unsigned shortdes valeurs de couleur allant jusqu'à 1023. Donc, jusqu'à ce que cela soit corrigé, voici une version utilisant charune valeur de couleur maximale de 255.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}
Martin Ender
la source
J'aimerais voir les canaux de couleur individuellement. Ce serait cool.
applaudir
52

Collines Logistiques

entrez la description de l'image ici

Les fonctions

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

Toutes les définitions doivent correspondre à BL sous 140 caractères. Voici la version non-golfée de l'algorithme bleu, légèrement modifié:

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

Là où les valeurs de x tombent le plus souvent pour une valeur donnée de r (j), le graphique devient plus clair (généralement décrit comme plus sombre).

Eric Tressler
la source
3
Aww, je pensais à la façon de faire celui-ci hier. +1 pour le comprendre. En fait, je pense que la palette est vraiment belle telle quelle! :)
Martin Ender
2
Je vous ai volé ces gâchis et votre githubphagocyte, bien que je prenne la responsabilité de la #de laid. Surtout "#define G for (".
Eric Tressler
1
ressemble plus à un visualiseur de support de tournoi
Kevin L
3
Pas de photo en haut: le vainqueur décède
Eric Tressler
1
Puis-je obtenir une impression de la taille d'une affiche? Avec 3 tweets fanés en arrière-plan. :-)
Andrew Cheong
50

Diffusion Agrégation Limitée

J'ai toujours été fasciné par l' agrégation limitée par la diffusion et le nombre de façons dont elle apparaît dans le monde réel.

J'ai eu du mal à écrire ceci en seulement 140 caractères par fonction, j'ai donc dû rendre le code horrible (ou beau, si vous aimez les choses comme ++d%=4et for(n=1;n;n++)). Les trois fonctions de couleur s'appellent et définissent les macros à utiliser. La lecture est donc difficile, mais chaque fonction comporte un peu moins de 140 caractères.

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

agrégation à diffusion limitée

Pour visualiser comment les particules s'agrègent progressivement, j'ai produit des instantanés à intervalles réguliers. Chaque image a été produite en remplaçant le 1 for(n=1;n;n++)par 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Cela le maintient juste sous la limite de 140 caractères pour chaque exécution.

agrégation animée

Vous pouvez voir que les agrégats qui se développent proches se privent les uns des autres de particules et croissent plus lentement.


En modifiant légèrement le code, vous pouvez voir les particules restantes qui ne sont pas encore attachées aux agrégats. Cela montre les régions plus denses où la croissance va se produire plus rapidement et les régions très clairsemées entre les agrégats où aucune croissance ne peut plus se produire car toutes les particules ont été épuisées.

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 avec particules visibles

Cela peut être animé de la même manière qu'auparavant:

agrégation animée avec des particules

trichoplax
la source
3
Très intéressant, +1.
internets est faite de chat
50

Spirale (140 exactement)

produit final

Cela correspond exactement à 140 caractères si vous n'incluez pas les en-têtes et les crochets de la fonction. C'est autant de complexité en spirale que je pourrais tenir dans la limite de personnage.

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

J'ai progressivement construit sur une simple spirale, en ajoutant des motifs sur les bords de la spirale et en expérimentant comment différentes spirales pourraient être combinées pour donner un aspect cool. Voici une version non-golfée avec des commentaires expliquant le rôle de chaque pièce. Jouer avec les paramètres peut produire des résultats intéressants.

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

Jouer avec les paramètres:

Ici, les spirales sont alignées mais présentent des motifs de bord différents. Au lieu des arêtes de blocs dans l'exemple principal, elle a des arêtes entièrement composées d'ondes de péché.

bords

Ici, le dégradé a été supprimé:

pas de dégradé

Une animation ( qui, pour une raison quelconque, ne semble pas boucler une fois après l'avoir téléchargée, désolée. J'ai également dû la réduire. Ouvrez-la dans un nouvel onglet si vous avez raté l'animation ):

animation

Et voici l' album imgur avec toutes les images qu'il contient . J'aimerais voir si quelqu'un peut trouver d'autres motifs en spirale sympas. En outre, je dois dire que c’est de loin l’un des défis les plus intéressants que j’ai jamais vu. Prendre plaisir!

EDIT: Voici quelques fonds réalisés à partir de ces spirales avec des paramètres modifiés.

De plus, en combinant mes motifs de bords en spirale avec certaines des fractales que j'ai vues ici grâce à l'utilisation de xor / et / ou d'opérations, voici une dernière spirale:

spirale fractale

Xleviator
la source
2
Ce sont fantastiques! Si vous regardez les autres réponses, vous pourrez peut-être trouver des idées pour jouer au golf encore plus bas si vous voulez plus d'espace. Quelques réponses utilisent #define dans une fonction pour définir une macro utilisable par toutes les trois. Vous pouvez ainsi transférer la plus grande partie du calcul à d’autres fonctions couleur. Martin Büttner m'a présenté ce truc.
Trichoplax
Je vous remercie! Dans mon cas, autant que je puisse trouver, mon code manque du type de modèle logique dupliqué qui bénéficierait de la livre sterling. Cependant, si vous en voyez, je vous serais reconnaissant de bien vouloir me les identifier, en particulier parce que je n'ai pas utilisé le C / C ++ de manière intensive depuis des années.
xleviator
Trouver des sections en double aiderait certes encore plus, mais même sans duplication, vous pouvez simplement déplacer le code de BL à RD ou GN en le définissant comme une macro dans RD ou GN, puis en l’utilisant dans BL. Cela devrait vous donner deux fois plus de place pour du code supplémentaire.
Trichoplax
Ah! Je vois. Je n'avais même pas réalisé que chaque corps de fonction avait lui-même la limite de 140 caractères. Je suppose que la prochaine fois, je devrais lire le message plus attentivement. Merci d'avoir fait remarquer cela!
xleviator
1
Comme cela a été discuté dans le chat , votre GIF non en boucle devrait être facilement réparable. Je pense que cela en vaut la peine, car la brève animation qu’elle montre actuellement est superbe.
Trichoplax
47

Hommage à un classique

V1 : Inspirée par "Be happy" de DreamWarrior, cette soumission simple incorpore une petite image pixel-art dans chaque canal de couleur. Je n'ai même pas eu à jouer au code!
V2 : maintenant avec un code considérablement plus court et une bordure noire épaisse n'isolant que "l'écran de jeu".
V3 : vaisseau spatial, balle, aliens endommagés et bordure bleue, oh mon dieu! Essayer de viser cela , à peu près.

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

Envahisseurs de l'espace


Je suis tombé par hasard sur un montage de Umber Ferrule dont l'avatar m'a inspiré pour ajouter une autre entrée basée sur le pixel art. Puisque l'idée de base du code est en grande partie similaire à celle de Space Invaders, je l'ajoute à cette entrée, bien que les deux aient clairement des points de défi différents. Pour ce dernier, obtenir le bon rose (au détriment du blanc) et le fait qu’il s’agisse d’un sprite plutôt grand ont été de bons défis. Les caractères d'échappement hexadécimaux ( \xFFetc.) du canal rouge représentent les caractères correspondants dans le fichier source (le canal rouge du fichier source contient des données binaires), alors que les caractères d'échappement en octal sont littéraux (c'est-à-dire présents dans le fichier source).

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

Bubble (Bubble Bobble)

Luciole
la source
3
J'aime cela. Beaucoup de place pour ajouter des fonctionnalités supplémentaires aussi ...
trichoplax
1
Yup, il y a beaucoup d'astuces à faire pour réduire la taille. Je pourrais essayer de l'étendre demain.
FireFly
C'est incroyablement court maintenant. Pourriez-vous adapter l'un de ces motifs de bits à la texture de votre réponse au raycasting ...?
Trichoplax
@ MartinBüttner oups, vous avez raison. Je l'ai corrigé et fait une autre mise à jour des fonctions.
FireFly
Neat, j'aime bien comment vous avez pris le pixel art 8x8 et l'avez "redimensionné" à la volée. Cependant, j'ai dû faire quelques changements et je ne comprends toujours pas exactement votre image. J'ai changé les 1L et 255L en 1LL et 255LL. Comme cela a rendu les choses meilleures, je suppose que vous compilez probablement en mode 64 bits et que des problèmes de largeur de bits empêchent le reste de mon image de se tromper. Mais bon travail!
DreamWarrior
44

Peinture d'action

Je voulais essayer de recréer quelque chose de similaire au travail de Jackson Pollock - des gouttes d'eau et de la peinture coulée sur une toile horizontale. Bien que j'aie aimé les résultats, le code a été beaucoup trop long à poster sur cette question et mes meilleurs efforts n'ont encore réduit que 600 octets environ. Ainsi, le code publié ici (qui a des fonctions respectives de 139 octets, 140 octets et 140 octets) a été produit avec une aide considérable de la part de certains génies du chat . Grand merci à:

pour une session de golf en groupe sans répit.

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

La macro E (q) est utilisée dans les fonctions RD et GR. Changer la valeur de l'argument change la façon dont les composants rouge et vert des couleurs changent. La macro J se termine par un nombre qui sert à déterminer l'ampleur de la modification de la composante bleue, ce qui affecte les composantes rouge et verte car elles sont calculées à partir de celle-ci. J'ai inclus quelques images avec les arguments rouge et vert de E variés pour montrer la variété de combinaisons de couleurs possibles. Survolez les images pour les valeurs rouge et verte si vous souhaitez les exécuter vous-même.

action painting 14, 14

action painting 63, 49

action painting 56, 42

action painting 0, 49

Toutes ces images peuvent être visualisées en taille réelle si vous les téléchargez. La taille du fichier est petite, car la couleur plate convient à l'algorithme de compression PNG. Aucune compression avec perte n'était donc nécessaire pour télécharger sur le site.

Si vous souhaitez voir des images de différentes étapes du processus de golf alors que nous avons essayé différentes choses, vous pouvez regarder dans le chat de peinture d'action .

trichoplax
la source
7
Je suis cette question et toutes les réponses depuis deux semaines maintenant, et je dois dire que c’est la première fois que ma mâchoire est tombée. SAINT AMAZINGNESS. Je veux dire, toutes les réponses ici sont excellentes - mais celle-ci est quelque chose que je n'aurais jamais imaginé possible.
Todd Lehman
1
@ToddLehman merci! Ce n'est certainement pas quelque chose dont je serais capable seul - je sais parce que j'ai essayé ...
trichoplax
2
IMPRESSIONNANT! L'un des meilleurs dans cette question et pour moi le seul (peut-être sauf le gagnant) qui ressemble à dessiné par l'homme :)
cyriel
1
@cyriel merci beaucoup. On pourrait dire que celui-ci a été dessiné par 5 humains ...
trichoplax
43

Je pensais jouer avec les paramètres de ce code ... Tout le mérite revient à @Manuel Kasten. Ce sont tellement cool que je ne pouvais pas résister à poster. Chaud froid

/* 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
la source
3
Pour moi, le Dr Seuss. Très cool!
DLosc
3
Haha, j'ai nommé les deux derniers fichiers Seuss1 et Sueuss2
Kyle McCormick
42

Edit: C’est maintenant une réponse valable, grâce aux déclarations forward de GRetBL .

S'amuser avec la séquence Q de Hofstadter! Si nous utilisons la distance radiale d'un point comme entrée et la sortie comme couleur inverse, nous obtenons quelque chose qui ressemble à du vinyle coloré.

entrez la description de l'image ici

La séquence est très similaire à la séquence de Fibonacci, mais au lieu de revenir en arrière de 1 à 2 étapes, vous prenez les deux valeurs précédentes pour déterminer le retour avant de prendre la somme. Il se développe grossièrement linéaire, mais de temps en temps, il y a une rafale de chaos (à des intervalles croissants) qui se résout ensuite en une séquence presque linéaire avant la prochaine rafale:

entrez la description de l'image ici

Vous pouvez voir ces ondulations dans l'image après les régions qui ont une couleur très "plate".

Bien sûr, utiliser une seule couleur est ennuyeux.

entrez la description de l'image ici

Maintenant pour le code. J'ai besoin de la fonction récursive pour calculer la séquence. Pour ce faire, je l'utilise RDchaque fois que jc'est négatif. Malheureusement, cela ne laisse pas assez de caractères pour calculer la valeur du canal rouge lui-même, donc RDappelle à son tour GRavec un décalage pour produire le canal rouge.

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

Bien sûr, c’est à peu près l’utilisation la plus simple possible de la séquence, et il reste encore beaucoup de caractères. N'hésitez pas à l'emprunter et à faire d'autres choses folles avec!

Voici une autre version où la limite et les couleurs sont déterminées par la séquence Q. Dans ce cas, il y avait assez de place RDpour que je n'ai même pas besoin de la déclaration anticipée:

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

entrez la description de l'image ici

Martin Ender
la source
1
Cette deuxième image gris-ish est magnifique!
tomsmeding
Pouvez-vous le compresser suffisamment pour utiliser les fonctions r / g / b elles-mêmes de manière récursive, avec des coordonnées non valides pour les appels récursifs?
Sparr
J'ai adoré l'image multicolore. Bonne réponse!
Alex
41

Ceci calcule la transformation de Joukowsky d'un ensemble de cercles concentriques centrés sur un point légèrement décalé par rapport à l'origine. J'ai légèrement modifié les intensités dans le canal bleu pour donner un peu de variation de couleur.

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

entrez la description de l'image ici

ossifrage délirant
la source
39

Objectif c

Réécrivez le code C ++ dans Objective-C parce que je ne pouvais pas le compiler ... Il donnait les mêmes résultats que les autres réponses lorsque je courais sur mon iPad, alors tout va bien.

Voici ma soumission:

Triangles Galore

Le code derrière est assez simple:

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

Vous pouvez zoomer sur les carrés en les multipliant iet jpar 0.5, 0.25etc. avant qu'ils ne soient traités.

Max Chuquimia
la source
Êtes-vous sûr que c'est le même code que vous avez utilisé? Le ^ a l’air bizarre, car (i ^ i) vaut toujours 0 (le XOR), et le ^ 2 ressemble plus à un carré qu’à un bit XOR.
Manuel Ferreria
1
@ManuelFerreria Avec XOR, le code est en fait compilé comme ceci: x^(x-y)^y(cela m'a jeté aussi la première fois). Si vous avez des fonctionnalités iOS, voici mon code: gist.github.com/Jugale/28df46f87037d81d2a8f
Max Chuquimia
38

Sierpinski Paint Splash

Je voulais jouer plus avec les couleurs, donc j'ai continué à changer mon autre réponse (la swirly) et finalement j'ai fini avec ça.

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

C'est mon avatar maintenant. : P

cjfaure
la source
4
Bon travail. monsieur, bon travail.
EaterOfCode
37

Je me sens obligé de soumettre cette entrée que j'appellerai "comportement indéfini", ce qui illustrera ce que fait votre compilateur avec les fonctions censées renvoyer une valeur mais ne:

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

Tous les pixels noirs:

tous les pixels noirs

Pixels pseudo-aléatoires:

pixels pseudo-aléatoires

Et bien sûr, une foule d'autres résultats possibles en fonction de votre compilateur, ordinateur, gestionnaire de mémoire, etc.

Sparr
la source
3
Lequel avez-vous eu?
tomsmeding
3
J'ai un noir uni et une couleur unie qui ont changé entre différentes exécutions du programme, avec différents compilateurs.
Sparr
8
Mon compilateur se contente d’erreurs et me crie de ne pas renvoyer de valeur.
Pharap
3
@Pharap ce n'est pas une mauvaise chose :)
Sparr
Je doute que vous obteniez jamais un aussi bon hasard, comme le suggère votre deuxième image. Une valeur constante, l'indice de la boucle, etc. sont beaucoup plus probables (tout ce qui est stocké dans EAX lorsque la fonction est appelée).
exemple
37

sensationnel

groovy.png

Juste quelques trigonométrie et astuces macro bizarres.

RD:

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

GR:

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

BL:

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

EDIT: si ce M_PIn’est pas autorisé car uniquement sur les systèmes compatibles POSIX, il peut être remplacé par le littéral 3.14.

Fraxtil
la source
1
Je vous avez des caractères de rechange, acos(-1)est un bon remplacement pour M_PI.
Martin Ender
33

Je ne suis pas bon en maths. J'ai toujours été pauvre élève en classe de mathématiques. Alors j'ai fait simple.

mathpic1.png

J'ai utilisé le code Javascript modifié de l'utilisateur 1455003 . Et ceci est mon code complet .

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

Il est très court pour que les trois fonctions tiennent dans un tweet.


mathpic2.png

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

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

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

Une autre fonction très courte. J'ai trouvé ce motif sierpinski (et un motif tangent) en jouant avec diverses fonctions mathématiques. C'est le code complet

Casse-croûte
la source
i&jRend juste le triangle de Sierpinski en fait. Ce qui est génial .
cjfaure
Ce dernier est digne de profil.
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;
}

Etats-Unis

Une autre version. les corps de fonction sont tweetables.

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

entrez la description de l'image ici

Fonction de rendu d'image révisée. 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)
}

Violet

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

entrez la description de l'image ici

wolfhammer
la source
TRICHEUR! TRICHEUR! ; D (c'est une réponse valable, trop astucieuse: P belle!)
tomsmeding
1
Hahah .. oui je sais donc j'ai soumis un qui est plus dans l'esprit de la question. En fait, j'ai essayé de faire des motifs et je me demandais si je pouvais réellement dessiner quelque chose.
Wolfhammer
Vous pouvez donner aux images couleur peu profondes un aspect légèrement plus riche en ajoutant du bruit de grain de film dans les bits inférieurs en appliquant un "| Math.random () * 256" à la fin. Rend les nuances plus foncées plus perturbées de manière aléatoire sans altérer les reflets. (et augmentez le nombre en fonction du seuil d'obscurité)
Kent Fredric le
rgb randomness @ [10,728,728] i.imgur.com/ms4Cuzo.png
Kent Fredric
31

Peintre planétaire

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

Inspiré par Martin superbe entrée , il s'agit d'une approche différente. Au lieu d'ensemencer de manière aléatoire une partie des pixels, je commence par le coin supérieur gauche sous le nom de RVB (512 512 512), puis effectue des marches aléatoires sur chaque couleur à partir de là. Le résultat ressemble à quelque chose d'un télescope (imo).

Chaque pixel prend la moyenne des pixels au-dessus / à gauche de celui-ci et ajoute un bit aléatoire. Vous pouvez jouer avec la variabilité en changeant lap variable, mais je pense que ce que j'utilise est un bon équilibre (principalement parce que j'aime le bleu, donc plus de volatilité du flou donne de bons résultats).

Il y a un léger biais négatif de la division entière lors de la moyenne. Je pense que cela fonctionne, cependant, et donne un bel effet d'assombrissement au coin inférieur.

Bien sûr, pour obtenir plus d'un résultat, vous devez ajouter une srand()ligne à votre fonction principale.

bandes

Géobits
la source
2
Si l'image était un peu plus grande, cela ressemblerait à des rayons de lumière. o:
cjfaure
1
@ cjfaure si vous affichez l'image en taille réelle (télécharger / cliquer avec le bouton droit de la souris et afficher l'image / tout ce qui fonctionne sur votre système), elle aura l'air encore plus belle avec des détails supplémentaires.
Trichoplax
faites-en un cercle entouré de noir et ça en fera une planète!
Khaled.K
1
J'ai essayé d'envelopper cela autour d'une sphère dans un mélangeur et j'ai rendu une animation. Voir ici: gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs
30

Ondes réfléchies

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

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

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

Un motif de base d'échiquier déformé en fonction de la position d'une vague se dilatant à partir d'un point semblable à une pierre tombée dans un étang (très loin de la précision physique!). La variable west le nombre de pixels à partir de ce point que la vague a déplacé. Si elle west suffisamment grande, l’onde reflète les côtés de l’image.

w = 225

vagues avec w = 225

w = 360

vagues avec w = 360

w = 5390

vagues avec w = 5390

Voici un GIF montrant une succession d’images au fur et à mesure que la vague s’étend. J'ai fourni un certain nombre de tailles différentes, chacune montrant autant d'images que la limite de taille de fichier de 500 Ko le permet.

vagues grand GIF

vagues petit GIF ondes moyennes GIF


Si je peux trouver un moyen de l'adapter, j'aimerais idéalement que les interférences de vagues soient modélisées de manière à ce que les ondes aient l'air plus réalistes lorsqu'elles se croisent. Je suis content de la réflexion cependant.

Notez que je n'ai pas vraiment modélisé la réflexion d'onde dans 3 lots de 140 octets. Il n'y a pas vraiment de réflexion en cours, il lui arrive juste de ressembler à ça. J'ai caché l'explication au cas où quelqu'un voudrait deviner en premier:

La première onde réfléchie est identique à une onde provenant de l'autre côté du bord de l'image, à la même distance que le point d'origine. Le code calcule donc la position correcte pour les 4 points requis pour obtenir l’effet de réflexion de chacune des 4 arêtes. Les autres niveaux d'ondes réfléchies sont tous identiques à une onde provenant d'une tuile plus éloignée, si vous imaginez l'image comme une tuile dans un plan. Le code donne l’illusion de 8 niveaux de réflexion en affichant 189 cercles en expansion distincts, chacun placé au bon endroit dans une grille de 17 sur 17, de sorte qu’ils traversent le carré central de la grille (c’est-à-dire le carré de l’image) à juste le bon moment pour donner l’impression du niveau de réflexion actuel requis. C’est simple (et bref!) De coder, mais s’exécute assez lentement ...

trichoplax
la source
3
Aimez les GIF et l'explication.
DLosc
Neato! Mais bon sang, les entrées comme celles-ci me font penser que j’ai besoin d’un ordinateur plus rapide (ou plus de patience, lol). Soit votre ordinateur est beaucoup plus rapide, soit je ne veux pas savoir combien de temps il vous a fallu pour générer tous ces cadres GIF.
DreamWarrior
3
@DreamWarrior Ce n'est pas moi qui suis patient. C'est mon ordinateur portable qui ne me dérange pas de courir pendant la nuit pendant que je dors ...
trichoplax
2
Je vois Pacman dans la deuxième image.
AL