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

Publié le 11 Novembre 2010

Benoit Mandelbrot n'est plus, mais les fractales, elles, sont toujours là, et pour longtemps. Et depuis longtemps aussi d'ailleurs. En hommage à ce grand Môssieur de l'imagerie mathématique, voici une petite série de fractales obtenues avec Processing avec une des méthodes les plus simples qui soit (que J... avait déjà programmé il y a vingt ans sur un Amiga, soit dit en passant).

 

La méthode est simple, placez un point dans le plan et appliquez à ses coordonnées une transformation géométrique: une rotation, une translation ou une homothétie. Tracez le point à ses nouvelles coordonnées et recommencez: appliquez à nouveau une de ces transformations et retracez. Recommencez ainsi de suite des millions de fois en alternant ces différentes transformations et vous avez de bonnes chances d'obtenir une fractale, plus ou moins déformée, plus ou moins connexe ou poussière. Voici quelques exemples:

 

fractal1-184-1

fractal1-284-1

fractal1-355-1

fractal1-649-1

fractal1-694-1

fractal1-700-1

fractal1-811-1

fractal1-833-1

fractal1-872-1

fractal1-910-1

fractal1-911-1

fractal1-983-1

 

Et pour ceux que cela intéresse, voici le code.

 

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, xcentre, ycentre;
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);
 
  x=int(random(sx));
  y=int(random(sy));
 
  xcentre=3*sx/5;//+vx/2;
  ycentre=3*sy/5;//+vy/2;
 
  h=50;
  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.3) {
      xnew=sx/2+ratio*(x-sx/2); ynew=sy/2+(y-sy/2)*ratio;
      h=constrain(h+10,0,100);
    } else if (test>0.7) {
      xnew=xcentre+(x-xcentre)*ratio*cos(theta)-(y-ycentre)*ratio*sin(theta);
      ynew=ycentre+(y-ycentre)*ratio*cos(theta)+(x-xcentre)*ratio*sin(theta);
      h=constrain(h-7,0,100);
    } else {
      xnew=100+(x-100)*cos(theta)-(y-100)*sin(theta);
      ynew=100+(y+100)*cos(theta)+(x-100)*sin(theta);
      h=constrain(h-8,0,100);
    }
   
    if (x>0 && x<sx-1 && y>0 && y<sy-1){
      xint=int(x)+1;
      yint=int(y)+1;
      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
 
  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("fractal1-" + numsequence + "-" + numeroimage + ".jpg");
    println("PHOTO "+ numsequence + " - " +  + numeroimage );
    numeroimage=numeroimage+1;
}

Publié le 17 Octobre 2010

Si vous suivez l'actualité scientifique, vous l'aurez appris: Benoit Mandelbrot est mort. Agé de 86 ans, le découvreur des fractales et de leur omniprésence s'est éteint à Cambridge le 14 octobre 2010.

 

Inutile de refaire ici sa biographie, puisqu'elle est régulièrement remise à jour sur Wikipédia.

 

Par contre, si vous voulez en savoir plus sur son travail, le mieux est de l'écouter directement. Voici donc le lien vers la conférence qu'il a donné le 28 juin 2000 dans la cadre de l'université de tous les savoirs. 71 minutes en français où Benoit Mandelbrot lui-même vous explique ce que sont les fractales, d'où elles viennent et où on les trouve.

 

Si le lien ne marche pas, suivez celui-ci, et tapez Mandelbrot dans le moteur de recherche, sa conférence s'appelle "L'anneau fractal de l'art à l'art à travers la géométrie, la finance et les sciences."