Fractales sur ESP32 (Mandelbrot - Julia)

Vous connaissez certainement les fractales, dont la plus connue est l'ensemble de Mandelbrot :

Voici un programme pour jouer avec sur ESP32. J'ai choisi l'ESP32 parce que je pense qu'il fera les calculs plus rapidement qu'un Uno (fréquence d'horloge plus élevée) : environ une seconde à une seconde et demi pour le calcul et l'affichage.

Le code affiche sur un écran TFT tactile de 320 x 240, et utilise la bibliothèque TFT_eSPI. Il calcule les ensembles de Mandelbrot et de Julia pour plusieurs valeurs d'exposant, et permet de zoomer sur des zones d'intérêt pour bien voir l'aspect fractal (c'est à dire la présence des mêmes structures à chaque changement d'échelle). Le niveau de zoom est limité du fait de la précision limitée des calculs, mais on peut faire une bonne demi douzaine de zooms avant que l'image se dégrade.

La photo ci-dessous est obtenue en zoomant sur la zone de gauche de l'image précédente.

Plusieurs palettes de couleurs sont proposées (ci-dessous un ensemble de Julia en rouge).

Le code est donné ci-joint. La bibliothèque TFT_eSPI définit les connexions dans un fichier setup (joint) qui doit être dans le répertoire de la bibliothèque. Il est possible de faire des setups spécifiques à un programme, je m'y attacherai plus tard.

Le code commence par afficher le mode d'emploi :

La majeure partie de l'écran est réservée à l'affichage des images, des boutons tactiles sont disponibles à droite de l'écran :

  • R : effectue un 'reset', c'est à dire remet l'image à son échelle maximale
  • U : 'undo' permet de revenir à l'étape précédente (en cas de zoom pas intéressant)
  • M ou J : permet de passer de l'ensemble de Mandelbrot à l'ensemble de Julia et réciproquement.

Il faut rentrer un peu dans les détails de la manière de calculer ces ensembles. Ces ensembles sont calculés par l'itération répétée d'une formule simple, dans notre cas z^n+c. z est un nombre complexe qui représente les coordonnées d'un point de l'affichage. n est un exposant entier (ici il peut varier de 2 à 7) et c est une constante.

Pour l'ensemble de Mandelbrot, pour tous les points de la zone d'affichage on commence par initialiser z à 0. La constante c est prise égale à la valeur des coordonnées du point considéré et on itère la formule.

Un point fait partie de l'ensemble si l'application répétée de cette formule ne diverge pas (c'est à dire n'entraîne pas les calculs vers des grands nombres). Il est démontré que si le résultat de la formule dépasse 2 (en module puisqu'on parle de nombres complexes) l'itération va diverger. Donc pour obtenir des jolies couleurs, on stoppe l'itération au moment où le résultat dépasse 2 et la couleur correspond au numéro de l'itération. Si le nombre d'itérations est trop grand (donc si le point fait partie de l'ensemble de Mandelbrot) on arrête à partir d'un seuil (Iter_max) et on associe la couleur noire à ce point.

L'ensemble de Julia est calculé de manière similaire à la différence près que l'on n'initialise pas les calculs à 0 mais à la valeur des coordonnées du point considéré et que la constante c est choisie par l'utilisateur pour l'ensemble de l'image.

Voila, j'espère que c'est clair. Ces explications permettent de mieux comprendre la suite du mode d'emploi :

Les libellés de certaines touches changent en fonction du contexte : elles affichent la fonction qui sera exécutée si on appuie dessus. Ainsi si on affiche l'ensemble de Mandelbrot, la touche M/J affiche J puisque si on appuie dessus on affichera l'ensemble de Julia (et réciproquement).

Même chose pour le choix de la palette de couleurs. On commence par la palette verte. La touche propose la palette suivante (la bleue). Les palettes sont : rouge, vert, bleu, gris, palette 1, palette 2 et on revient au rouge. Les deux dernières sont des essais de palettes multicolores, peu concluants mais ça change un peu et ça permet de voir mieux certains détails.

La touche avec un nombre permet de choisir l'exposant n, en boucle de 2 à 7. Dans le même esprit, elle affiche 3 si vous êtes à 2...

Enfin, lors de l'affichage de l'ensemble de Julia, il faut choisir la valeur de la constante c : la touche C permet de le faire, grâce à un sélecteur :

EDIT : j'ai oublié de préciser le principal. Cliquer sur l'image permet de zoomer autour du point sélectionné.

Mandel_ESP32_touch2.ino (9.56 KB)

User_Setup.h (11.1 KB)

Encore quelques images :
Le montage, quelques ensembles de Julia et les temps de calculs.

Enjoy !

Autres images

Améliorations à venir :

  • Augmenter la profondeur de zoom par méthode "de perturbation"
  • Diminuer le temps de calcul en passant en virgule fixe Je suis preneur de toute aide sur ce dernier point...

super boulot. Le rendu a l'air d'être au top.

Bonne continuation.

J'ai un instructable en préparation, pour soumettre au concours "Made with maths". Je vous tiens au courant...

Hello, en attendant, voici une nouvelle version toujours pour ESP32, mais avec une taille d’écran paramétrable (hauteur et largeur dans l’entête). Les temps de calcul et d’affichage sont de l’ordre de 3 secondes pour un écran de 480 x 320 pixels, avec une profondeur de zoom de 6 à 7 zooms consécutifs.

J’ajoute une version en double précision (64 bits au lieu de 32 bits pour les flottants), bien moins rapide. Les temps peuvent dépasser les 20 secondes dans des images un peu complexes. C’est normal, l’ESP32 dispose d’un accélérateur matériel pour les calculs en flottants sur 32 bits. Si on passe en 64 bits, tout est fait en soft, et c’est plus lent. Par contre, on peut aller à plus de 15 niveaux de zoom, donc voir des détails bien plus fins !!!

Enjoy !

Mandel_ESP32_480x320.ino (11.1 KB)

Mandel_ESP32_480x320_double.ino (11.1 KB)

Bel écran de veille pour ESP32 lesept.

L'écran veille, mais le processeur est bien occupé... :)

Hello, l'instructable est publié, si vous voulez le consulter et voter...

L'Instructable a été accepté dans le concours : vous pouvez voter si le cœur vous en dit...

hello,

à voté

bravo pour cette créativité et ce partage :)

+1

et plus 1 aussi 8)

Merci, merci !

Je découvre ton projet. Ça me rappelle quand on programmait ça avec mon frangin sur le 80286 à 10 MHz :grin: . On ne mettait pas une seconde pour tout l'écran mais plutôt pour une ligne. Il n'y avait pas de processeur numérique et je ne garantis pas que notre implémentation des calculs sur les nombres complexes était optimale :) .

Félicitations, je n'aurais même pas pensé à tenter sur arduino.

Pour ceux que ça intéresse, je viens de recevoir le résultat du concours. J'ai reçu ce qu'ils appellent un deuxième prix, c'est à dire que je suis classé entre 5 et 10ème, sur plus de cent participations

hello
c’est déjà très bien :smiley:

Félicitations :slight_smile:

C'est cool ! Bravo.