|
||||||||||||||||||||||||||||||||||||||||
|
PROGRAMMATION – PROCESSING Fonctions paramétrables Comment réaliser le même traitement avec des
paramètres variables ? Notion de fonctions paramétrables et de récursivité. Création de dessins fractals. |
|
|
|||||||||||
|
Programme int nx=50; int
ny=50;int kt=0; void setup () { size
(500, 500);background (255); rectMode
(CENTER); frameRate
(1); } void draw () { affiche (); dessine
(nx, ny); ny = ny + 50; kt = kt + 1; if (ny > 450) {ny = 50; kt = 0; background (255);} } void dessine (int
x, int y) { fill
(#FAEE08); rect
(x, y, 40, 40); fill
(#1805FC); rect
(x, y, 20, 20); } void affiche () { fill
(255,0,0); textSize (20); text
(( kt+" "+ny), 100, ny); fill
(255); } |
Dessin
|
But Répéter un dessin en utilisant une fonction paramétrable. Programme Initialisation classique. On précise que les
rectangles seront centrés. La commande frameRate
ralentit ou accélère l'affichage. Avec draw, on
appelle la fonction affichage qui présente deux paramètres à l'écran: le
numéro du dessin et son ordonnée. Puis appel à une fonction que nous appelons dessine, paramétrées avec x et y. L'ordonnée est incrémentée de même que le
compteur. Si l'ordonnée dépasse 450, ces deux paramètres sont réinitialisés. Avec la commande de fond d'image blanc, l'image
est effacée. Avec dessine,
deux rectangles colorés sont présentés. Exécution Les rectangles concentriques sont dessinés les
uns sous les autres accompagnés des deux paramètres. |
|||||||||
|
Apprentissage des instructions
|
|||||||||||
|
|
||||||||
|
Programme void setup () { size
(500,300); background
(255); strokeWeight(2); colorMode
(HSB, 500, 128, 128); arbre(width/2,
50, 100); } void arbre (float
x, float y, float
dim) { stroke
((x*y)%500, 128, 128); line
(x, y, x+dim, y+dim); line
(x, y, x-dim, y+dim); if
(dim > 1) { arbre (x-dim, y + dim, dim/2);
arbre (x+dim, y + dim, dim/2);
} } |
But Utiliser les fonctions pour réaliser un dessin fractal.
Mise en évidence de la récursivité
du langage Processing. Programme Initialisation classique. Avec un premier appel à la fonction arbre que nous allons décrire. Notez que le
troisième paramètre vaut 100. Description de la fonction arbre qui reçoit trois paramètres (x, y et dim). Notez que la première valeur de dim est donc 100. Dessin de deux lignes obliques à 90°. Puis, appel de la fonction arbre dans la fonction arbre en ayant pris la
peine de diviser dim par 2. Sans la condition if,
la répétition (récursion) se poursuivrait sans fin, du moins jusqu'à
déclaration forfait du programme (32 cycles autorisés). Arrêt dès que la
dimension est réduite en-dessous de 1. La couleur est une fonction du produit xy ajouté
à 500 au maximum (effet de mod 500). Exécution Le programme explore les côtés gauches de chaque
ramification et remonte progressivement avec le côté droit. |
|||||||
|
Dessin
Apprentissage des instructions
|
||||||||
|
|
||
|
Programme void setup() { size(600,
600); background(0); stroke(255); Arbre(300, 550, 9); } void Arbre(float
x, float y, int
taille) { float
Angle = radians(20); float
Longueur = 10.0; if
(taille > 0) { pushMatrix(); translate(x, y - Longueur * taille); line(0, Longueur * taille, 0, 0); rotate(Angle); Arbre(0, 0, taille - 1); rotate(2 * -Angle); Arbre(0, 0, taille - 1); popMatrix(); } } |
But Arbre fractal dont les branches se divisent toujours en deux. Programme En setup,
déclaration d'une nouvelle fonction nommée Arbre. Description de la fonction Arbre,
alimentée par trois variables. Définition de l'angle entre branches et de leur
longueur initiale. Exécution de la récursion tant que la taille
évolutive est positive. Mise en mode local avec push
et pop Matrix. Jeu de translations et rotations. Dessins de la branche. Appel récursif (répétitif) à la fonction branche
pour dessiner des branches de plus en plus petites au bout des précédentes. Exécution L'arbre apparait instantanément. Modifier les paramètres pour expérimenter les
différents types d'arbres obtenus. |
|
|
Dessin
|
||
|
|
||||||||
|
Programme float zx, zy, aY = 0.257; float maxIter = 300; int kt = 0; void setup() { size(700,
500); frameRate
(3); } void draw() { if
(kt < 30 ) { aY = aY + kt*0.0001; Julia (-0.7, aY); affiche (aY, kt); kt++; } } void Julia(float
cX, float cY) { for
(int x = 0; x < width; x++) { for (int y =
0; y < height; y++) { zx = 1.5 * (x - width / 2) / (0.5 * width); zy = (y - height / 2) / (0.5 * height); float i = maxIter; while (zx * zx + zy * zy < 4 && i
> 0) { float tmp = zx * zx - zy * zy + cX; zy = 2.0 * zx * zy + cY; zx = tmp; i -= 1; } colorMode(HSB);
color c = color(i
/ maxIter * 255, 255, set(x, y, c); } } } void affiche (float
coul, int iter) { fill
(255, 0, 0); textSize
(20); text
(iter+"
"+coul, 10, 50); fill
(255); } |
But Réaliser un diaporama de l'ensemble Julia selon
l'ajustement d'une constante. L'algorithme de création des fractales Julia est décrit en pages Fractales:
analyse de divergence d'un nombre complexe porté au carré de
façon récurrente au carré plus constante. Programme Initialisation des variables. En setup, on adapte le rythme de rafraichissement
pour visualiser les images façon diapositives (frameRate). En draw, la
variable compteur (kt) indique le numéro
de la diapositive. Le paramètre aY
est ajusté et soumis à une progression à chaque nouvelle diapositive. Appel aux fonctions Julia
– dessin de la fractale – et Affiche –
montre les valeurs des paramètres évolutifs. Fonction Julia:
Balayage de l'image en x et y et, pour chaque point, étude de la divergence
du nombre complexe avec partie réelle zx
et partie imaginaire zy. L'analyse en
profondeur (i) se poursuit sur 300
itérations (maxIter). Le mode HSB
est invoqué de manière à disposer d'une palette continue de couleurs. La couleur
déterminée, un point prenant cette couleur est déposé en x, y (set). La fonction affiche
sert à présenter le numéro de la diapositive et la valeur progressive de aY. Bien
sûr, on aurait pu faire évoluer -0,7 dans Julia. Exécution Les images, dont une sélection est montrée
ci-dessous, se présentent successivement accompagnées de leur numéro. |
|||||||
|
Progression
de l'ensemble de Julia (numéro de l'itération et valeur de aY)
Apprentissage des
instructions: deux astuces …
|
||||||||
|
|
||
|
Programme double x, y, zr, zi, zr2, zi2, cr, ci, n; double zmx1, zmx2, zmy1, zmy2, f, di, dj; double fn1, fn2, fn3, re, gr, bl, xt, yt,
i, j; void setup() { size(500, 500); di = 0; dj = 0; f = 10; fn1 = random(20); fn2 = random(20); fn3 = random(20); zmx1 = int(width /
4); zmx2 = 2; zmy1 = int(height /
4); zmy2 = 2; } void draw() { if (i <= width)
i++; x = (i + di)/ zmx1 - zmx2; for ( j = 0; j <= height;
j++) { y = zmy2 - (j + dj) / zmy1; zr = 0; zi = 0; zr2 = 0; zi2 = 0; cr = x; ci = y; n = 1; while (n < 200 && (zr2 + zi2) < 4)
{ zi2 = zi * zi; zr2 = zr * zr; zi = 2 * zi * zr + ci; zr = zr2 - zi2 + cr; n++; } re = (n * fn1) % 255; gr = (n * fn2) % 255; bl = (n * fn3) % 255; stroke((float)re,
(float)gr, (float)bl);
point((float)i,
(float)j); } } void mousePressed() { background(200); xt = mouseX; yt = mouseY; di = di + xt - float(width /
2); dj = dj + yt - float(height
/ 2); zmx1 = zmx1 * f; zmx2 = zmx2 * (1 / f); zmy1 = zmy1 * f; zmy2 = zmy2 * (1 / f); di = di * f; dj = dj * f; i = 0; j = 0; } |
But Dessiner l'ensemble de Mandelbrot avec possibilité
de zoom autour du point cliqué. Programme Le programme est largement inspiré de celui
présenté en Mandelbrot
set – Rosetta Code. L'algorithme de création des fractales de
Mandelbrot est décrit en pages Fractales:
analyse de divergence d'un nombre complexe porté au carré de
façon récurrente. Très proche de
l'ensemble de Julia. Avec la fonction MousePressed,
le programme est relancé sur une petite fenêtre entourant le point visé. Exécution Ce programme présente le "pou" de
Mandelbrot (illustration ci-dessous),
puis en cliquant, des zones de plus en plus détaillée. Chaque image est calculée en moins de 8 secondes
et elles apparaissent au fur et à mesure d'un balayage de gauche à droite. Dessin initial
|
|
|
Zoom
|
||
Voir Programmation de
cet ensemble avec Scratch,
avec Maple
|
Fut un temps, dans les
années 1980 et avec les moyens de calculs de l'époque, nous étions quelques
uns parmi mes collègues à découvrir la magie des fractales et à commenter nos
découvertes. Leur programmation n'était
pas compliquée. Plus délicat, le réglage des paramètres de calcul. Sachant
que la moindre image exigeait une demi-heure de traitement. Certains
prenaient des photos pour conserver les précieuses images. Plus tard (1988), est arrivé
le logiciel fractint qui
permettait de produire toutes sortes de fractales. Aujourd'hui, les
programmeurs rivalisent de prouesses pour:
Voir Best
16 Fractal Generators for You [2D/Online/Free] – Benjamin Arango – 22 01 2021 – Voir la vidéo des fractales en volume |
|
Retour |
|
|
Suite |
|
|
Voir |
|
|
Cette page |
http://villemin.gerard.free.fr/aInforma/PROCESNG/Fonction.htm
|
Externe
|
Processing |
|
|
Livres |
|
