Publié le 28 Novembre 2010

Après les fractales générées par double rotation et celles générées par double rotation symétrique, voici les fractales générées par triple rotation aléatoire. "Mais qu'est-ce que ca change ?" demanderont certains. Hé bien ca change tout, car on ne retrouve plus les fractales classiques à la géométrie sobre et tellement mathématique. Ici, on tombe dans la naturel, on voit des sortes de plantes, des lichens, des éponges, des fougères, des dragons, des hippocampes et plein de choses qui n'ont plus rien de mathématique. Et le tout en vidéo qui bouge !

 

 

Publié le 22 Novembre 2010

Alors que les formes générées par une triple rotation sont assez répétitives à part le triangle de Sierpinski, les formes générées par trois rotations aléatoires sont autrement plus riches en surprises. En voici quelques exemples où plusieurs formes sont parfois rassemblées sur la même image pour simplifier la mise en ligne. Une animation devrait bientôt arriver pour voir comment évoluent ces machins lorsqu'on fait varier les paramètres. Encore merci à Processing de rendre les choses aussi faciles !

 

fractale triple 20 20

fractale triple 29 23

fractale triple 343 46

fractale triple 361 46

fractale triple 457 23

fractale triple 460 11

fractale triple 524 36

fractale triple 553 33

fractale triple 687 13

fractale triple 847 7

fractale triple 860 35

fractale triple 875 21

fractale triple 916 16

fractale triple 956 20

Publié le 21 Novembre 2010

Si les doubles rotations faisaient déjà apparaître de nombreuses fractales, qu'elles soient symétriques ou pas, elles ne faisaient qu'entrevoir une des figrues bien connues des mathématiques: le Triangle de Sierpinski. Mais ça n'a rien d'étonnant en fait, car un triangle a 3 sommets et qu'une rotation triple est donc plus à même de le générer.

 

Et c'est exactement ce qu'il se passe quand on cherche les invariants de trois rotations dans le plan. C'est triangle de Sierpinski qui ressort régulièrement. D'ailleurs, c'est à peu près la seule figure remarquable qu'on trouve avec cette transformation. En voici quelques images:

 

fractale triple rotation-853 42

fractale triple rotation-200 849

fractale triple rotation-541 931

 

Par contre, les autres figures étant plutôt banales, il n'y aura pas d'animation cette fois-ci. A moins que...

Publié le 21 Novembre 2010

Voilà ce qu'il peut se passer lorsque vous lancez Processing alors qu'un lecteur vidéo Flash est déjà en train de tourner. C'est plutôt bizarre puisqu'aucun des deux ne plante, mais que l'interface Processing essaie d'afficher la vidéo et que le mode plein écran du lecteur Flash ne fonctionne plus... Etrange.

 

bug processing

Publié le 14 Novembre 2010

Décidément, ce qui se voulait être juste un hommage ponctuel à Benoit Mandelbrot commence à prendre l'allure d'une enquête échevelée ! Dans l'article sur les premières images de la double rotation homothétique, on avait vu que certaines formes avaient un air de déjà vu. Certaines images ressemblaient beaucoup à l'ensemble de Julia, notamment. Mais J... vient de mettre le doigt sur une vraie bombe (qui n'en est plus un en fait depuis 1988 (voir plus loin), époque où J... commençait à faire des fractales sur un Amiga...).

 

Quelle est donc cette bombe ?

 

Cette bombe est une transformation, assez ressemblante de la précédente, mais qui cache dans ses attracteurs une foule de formes qui ont fait l'histoire des mathématiques. Et oui, rien que ça ! Une simple transformation à deux paramètres, qui génére à elle toute seule (avec l'année de découverte et la dimension fractale du machin):

- la courbe de Lévy (1938, dimension 1.93)

- la poussière de Cantor (1883, dimension 0.63)

- le carré de Cantor ( ? , dimension 1.26)

- un triangle qui ressemble au tapis de Sierpinski (1906, dimension 1.89)

- la fractale de Cesaro (1906, dimension 1.78)

- la courbe de Von Koch (1906, dimension 1.26)

- un triangle de Sierpinski rempli,

- et un rectangle fractal obtenu par transformation du triangle précédent.

 

Et oui, tout ca dans une seule transformation. Mais laquelle, direz-vous ? Deux rotations homothétiques symétriques autour de deux points du plan... c'est tout...

 

Pour les curieux, tout cela n'est finalement pas étonnant, puisque toute ces courbes ou ces formes géométriques emblématiques appartiennent à la même famille, obtenue dans la théorie des fonctions itérées, proposée en 1981 par John Hutchinson et exploitée pour les fractales en 1988 par Barnsley...

 

Avant de montrer les images, sachez qu'une vidéo est en préparation où vous pourrez voir toutes ces courbes se transformer l'une en l'autre !

 

fractale poussière de Cantor

Poussière de Cantor

 

fractale carré de Cantor

Carré de Cantor

 

fractale courbe de Von Koch

Courbe de von Koch

 

fractale Cesaro

Fractale de Césaro

 

fractale courbe de Levy

Courbe de Lévy

 

fractale type Sierpinski

Triangle ressemblant à un tapis de Sierpinski

 

fractale triangle

Triangle cachant un triangle de Sierpinski

 

fractale rectangulaire

Rectangle obtenu par transformation douce du triangle précédent

Publié le 13 Novembre 2010

Les lecteurs les plus avertis auront surement remarqué que les images présentées dans le dernier article n'avaient pas les mêmes dimensions que celles présentées dans l'avant-dernier article sur les fractales générées blablabla. Et c'est tout à fait normal, car l'applet utilisé pour ces dernières avait été redimensionné en vue de la préparation d'une animation vidéo des images présentées dans l'avant dernier article sur les fractales blablabla. Et voici le résultat.

 

 

Publié le 13 Novembre 2010

Précédemment sur le blog à J..., on voyait à quoi ressemblaient des fractales générées par une double rotation homothétique. C'est vrai que c'est joli, mais ça a quand même un petit goût de déjà vu. Donc, dans ce cas-là, ce qu'il y a de mieux à faire, c'est de paramétrer le code pour tracer ces mêmes courbes un peu différemment: un petit balayage sur les angles avec un ratio fixe ou l'inverse, un balayage fin ou discret avec un pas fractionnaire de pi, ou ce genre de chose. Et voilà ce que ca donne:

 

fractale 143 5365

fractale 14 797

fractale 332 6848

fractale 333 2749

fractale 350 924

fractale 580 252

fractale 694 2891

fractale 694 6401

fractale 740 4191

fractale 798 1599

fractale 863 1102

fractale 977 2691

Publié le 11 Novembre 2010

Le petit hommage à Benoit Mandelbrot risque en fait de durer un peu plus longtemps que prévu. Puisqu'avec Processing, une idée en amène facilement une autre, voici la question à laquelle on tente de répondre ici: à quoi ressemblent les attracteurs étranges d'une transformation consistant à appliquer la même rotation homothétique alternativement centrée sur deux points distincts ?

 

Gniaa ! Kek ça veut dire ?

 

Soient deux points A et B du plan. Définissons une rotation homothétique d'angle theta et de rapport alpha (alpha<1). Prenons un point quelconque du plan, traçons le. Calculons l'image de ce point par la rotation homothétique centrée sur A, traçons le nouveau point. Faisons pareil en centrant la rotation sur B, et traçons le nouveau point. Recommençons sur A, puis sur B, et ainsi de suite, des millions de fois. Traçons chacun des points et regardons le résultat: Ho mon dieu ! Des fractales... Comme c'est bizarre !

 

fractale par double rotation-17 1

fractale par double rotation-207 1

fractale par double rotation-216 1

fractale par double rotation-437 1

fractale par double rotation-462 1

fractale par double rotation-538 1

fractale par double rotation-659 1

fractale par double rotation-729 1

fractale par double rotation-914 1

fractale par double rotation-921 1

fractale par double rotation-958 1

fractale par double rotation-992 1

 

Et pour ceux qui voudraient jouer avec, voici le code Processing pour s'amuser:

 

int sx, sy, ii, npts, xint, yint, nmax, nmoy, numsequence, numeroimage;
float h, s, b, test;
float ratio, theta, x, y, vx,vy, xnew, ynew, xcentre1, ycentre1, xcentre2, ycentre2;
float rmin, rmax, tmin, tmax, vxmin, vxmax, vymin, vymax;
float[][][] nhsv;

void setup(){
  sx=600;
  sy=400;
  size(sx,sy);  
  nhsv = new float[sx][sy][4];
 
  npts=1000000;
 
  colorMode(HSB,100);
 
  rmin=0.01;
  rmax=0.99;
  tmin=2*PI/360*0;
  tmax=2*PI/360*360;
  vxmin=-1*sx/2;
  vxmax=1*sx/2;
  vymin=-1*sy/2;
  vymax=1*sy/2;
 
  ratio=random(rmin,rmax);
  theta=random(tmin,tmax);
 
  vx=random(vxmin,vxmax);
  vy=random(vymin,vymax);
 
  xcentre1=0.35*sx;
  ycentre1=0.5*sy;
  xcentre2=0.65*sx;
  ycentre2=0.5*sy;
 
  println("vx " + vx + "------- vy " + vy);
 
  x=xcentre1;
  x=xcentre2;
 
  h=10;
  s=70;
  b=100;
 
  stroke(h, s, b,10);
   
  background(0,0,0);
  numeroimage=1;
  numsequence=int(random(1,1000));
}

void draw(){
 
  for (int ii = 0; ii < npts; ii=ii+1) {
    test=random(1);
   
    if (test<0.5) {
      xnew=xcentre1+(x-xcentre1)*ratio*cos(theta)-(y-ycentre1)*ratio*sin(theta);
      ynew=ycentre1+(y-ycentre1)*ratio*cos(theta)+(x-xcentre1)*ratio*sin(theta);
      h=constrain(h-18-random(4),0,100);
    } else {
      xnew=xcentre2+(x-xcentre2)*ratio*cos(theta)-(y-ycentre2)*ratio*sin(theta);
      ynew=ycentre2+(y-ycentre2)*ratio*cos(theta)+(x-xcentre2)*ratio*sin(theta);
      h=constrain(h+18+random(4),0,100);
    }
   
    if (x>0 && x<sx-1 && y>0 && y<sy-1){
      xint=int(x); yint=int(y);
      nhsv[xint][yint][1]=(nhsv[xint][yint][0]*nhsv[xint][yint][1]+h)/(nhsv[xint][yint][0]+1); // on recalcule la composante h moyenne
      nhsv[xint][yint][0]=nhsv[xint][yint][0]+1; //on compte ce point supoplémentaire à cette position.
    }
   
    x=xnew;
    y=ynew;
  } // fin du for
 
  // on retrace l'image à partir de la matrice nhsv
 
  for (int i = 1; i < sx-2; i=i+1) {
    for (int j = 1; j < sy-2; j=j+1) { 
      nhsv[i][j][1] = (20*nhsv[i][j][1] + nhsv[i+1][j][1] + nhsv[i-1][j][1] + nhsv[i][j-1][1] + nhsv[i][j+1][1] )/24; 
    }
  }
 
  nmax=0; // d'abord on balaie tout pour trouver le mex d'intensité
  for (int i = 0; i < sx-1; i=i+1) {
    for (int j = 0; j < sy-1; j=j+1) { 
      if (nhsv[i][j][0] > nmax) { nmax=int(nhsv[i][j][0]); }
    }
  }
 
  // en fonction du max, on met la valeur v à 0 ou 100 proportionnellement
  for (int i = 0; i < sx-1; i=i+1) {
    for (int j = 0; j < sy-1; j=j+1) { 
      nhsv[i][j][3] = constrain(10*(12+log(nhsv[i][j][0]/nmax)),0,100);
      stroke(nhsv[i][j][1], s, nhsv[i][j][3]);
      point(i,j);
    }
  }
} // fin du draw

void mousePressed() {
  saveFrame("fractale_par_double_rotation-" + numsequence + "_" + numeroimage + ".jpg");
    println("PHOTO "+ numsequence + " - " +  + numeroimage );
    numeroimage=numeroimage+1;
}