Licence CC BY-NC

Le lapin qui valait 1 milliard (de pixels)

Personne n'était prêt

Publié :
Auteur :
Catégories :
Temps de lecture estimé : 4 minutes

Suivez ce guide professionnel pour procrastiner.

L'histoire d'un homme qui ne savait que faire de son samedi

Il est 23h40, ce samedi 30 janvier 2017. J’ai enfin terminé le calcul monstrueux de la soirée.


Le lapin de Douady, c’est une fractale bien connue. C’est un exemple d’ensemble de Julia et est donc relativement facile à faire calculer par un ordinateur.

En 2015, je m’intéressais justement à ces ensembles de Julia, et à cette occasion j’avais écrit un programme pour simuler des ensembles de Julia.

À l’époque, je faisais des images de la taille de mon moniteur, donc de l’ordre de 1920 x 1080.

Mais ça, cher(e)s ami(e), c’était petit joueur. En ce beau samedi (à vrai dire je ne sais pas quel temps il a fait dehors) j’ai refait moultes simulations en poussant la résolution beaucoup plus loin.

J’ai commencé doucement par des simulations en 8K, c’est-à-dire avec une largeur de 4320 pixels. C’est chouette, et puis on peut zoomer un peu, ce que je pouvais jamais faire avant.

Spoiler pour une image en 20640 ✕ 17280 (16 x 1080p): Attention lag probable

Le lapin en résolution de (seulement) 20640 ✕ 17280, ce qui fait quand même un bon paquet de pixels

Mais j’ai poussé le vice plus loin. (Peut-être trop?)

Le cher lapin de Douady je l’ai réalisé non pas en 8K (= 4 x 1080p), non pas en 8 x 1080p, non pas en 16 x 1080p (celle dans la balise précédente) mais en 27 x 1080p.

J’ai simulé une image du lapin dont la taille est de :

$$34830 \times 29160 = 1 \; 015 \; 642 \; 800 \; {\rm pixels}$$

Et oui, j’ai passé la barre du milliard de pixels. Pourquoi ? Parce que je le peux :magicien: (et puis c’était un peu la limite de mon PC si je voulais pas lancer un calcul abusément long pour son petit proco)

C’est facile, si vous vouliez voir tous les pixels simultanément il vous faudrait 490 moniteurs de résolution 1920 x 1080. Chiche ?


Autant vous dire que la taille excessive rend l’image quasiment inutilisable (peu de logiciels acceptent sans d’énormes lags …). Je suis trop en avance sur mon temps, keskevousvoulez :-°

Mais si vous voulez tenter le diable, j’ai hébergé le fichier ici.


Fun fact

Du fait que l’image est relativement peu complexe, la taille reste très modérée. Voici en tableau les tailles des fichiers que j’ai obtenu pour une même image mais dans des résolutions différentes.

Largeur de la résolution Taille
4 x 1080p 987 Ko
8 x 1080p 2,9 Mo
12 x 1080p 5,2 Mo
16 x 1080p 7,8 Mo
27 x 1080p 16,8 Mo

On est sur des tailles de fichiers très petites respectivement à la quantité de pixels. La dernière correspond à 1 Milliard de pixels mais ne demande que 17 millions d’octet, soit quasiment 100 fois moins d’octets que de pixels.


Vous avez aimé ? Retrouvez mes Julia en 8K dans ma galerie :)

Petit extrait, je mets mes deux favorites <3

"Galaxie"
"Collier"

17 commentaires

J’aurais bien aimé trouvé dans ton billet quelques informations sur le temps de calcul pour générer les images, avec quel ordinateur et le langage utilisé. Un lien vers le code source serait un must-have !

Après, ne serait-il pas plus intéressant de générer l’image de façon intéractive (c’est à dire en zoomant sur la figure) ? Dans le cadre des fractales de Julia, il me semble que l’on peut connaître la valeur d’un pixel de façon locale, donc pas besoin de connaître tous les points de l’image.

+0 -0

J’aurais bien aimé trouvé dans ton billet quelques informations sur le temps de calcul pour générer les images, avec quel ordinateur et le langage utilisé. Un lien vers le code source serait un must-have !

Environ 1h10 de calcul pur en dual-core à 1,7 Ghz (pas de GPU) et 1h d’inscription (single-core) dans le fichier parce que les 24 Go de mémoire n’était pas intégralement dans la RAM et donc fallait se tapper du temps d’accès en SSD …

Sinon j’ai fait le programme en C++. Le code est un peu sale à lire alors je préfère pas le partager, mais si y a un vrai intérêt je peux le donner ..

D’ailleurs y aurait probablement moyen de l’optimiser un peu plus, vu mes piètres talents de codeur. Mais les perfs me semblent correctes (en temps normal) alors j’ai pas plus insisté.

C’est ce que j’ai trouvé de plus rapide et pratique comme langage. Mais je suis tout ouï pour des suggestions.

Après, ne serait-il pas plus intéressant de générer l’image de façon intéractive (c’est à dire en zoomant sur la figure) ? Dans le cadre des fractales de Julia, il me semble que l’on peut connaître la valeur d’un pixel de façon locale, donc pas besoin de connaître tous les points de l’image.

De façon locale ?

Tu veux dire en partant du principe que c’est semblable à zoom près ?

Alors sur le principe, c’est tentant, mais dans les faits il est difficile de savoir par quelle transformation c’est semblable. En tout cas j’ai pas plus travaillé cette piste du fait des difficultés mathématiques, mais peut-être qu’avec du courage y a des résultats possibles.

Par hazard, ça serait possible de modifier ton programme pour qu’il "streame" les pixels un à un, ligne par ligne histoire de ne pas avoir à stocker 24 Gio du tout (sans trop casser les performances) ? Bon évidemment il faudrait que le truc qui encode le fichier de sortie accepte un flux de pixels en entrée.

(Soyons fous, si tu as pu faire 1 milliard sur un PC de monsieur-tout-le-monde c’est qu’on peut faire énormément plus :-) )

JPEG/JFIF supports a maximum image size of 65,535×65,535 pixels

Bon, on va être vite bloqués… Mais un ensemble de tuiles précalculées explorables avec quelque chose comme leaflet, ça pourrait être intéressant.

Édité par motet-a

+0 -0

Par hazard, ça serait possible de modifier ton programme pour qu’il "streame" les pixels un à un, ligne par ligne histoire de ne pas avoir à stocker 24 Gio du tout (sans trop casser les performances) ? Bon évidemment il faudrait que le truc qui encode le fichier de sortie accepte un flux de pixels en entrée.

Je suis pas assez bon codeur pour me lancer dans ce genre de choses, faudrait que je me motive à apprendre …

(Soyons fous, si tu as pu faire 1 milliard sur un PC de monsieur-tout-le-monde c’est qu’on peut faire énormément plu

À vrai dire c’est parce que seule la technique me freine ici. Mais si Monsieur Toutlemonde veut s’y mettre, il aura quelques problèmes de maths à résoudre que j’ai moi-même résolu en 2015 .. Rien de très méchant, mais ça freine

Édité par Holosmos

Sinon j’ai fait le programme en C++. Le code est un peu sale à lire alors je préfère pas le partager, mais si y a un vrai intérêt je peux le donner ..

Holosmos

Ceci n’a jamais été un bon argument pour ne pas faire une release des sources.

Tu veux dire en partant du principe que c’est semblable à zoom près ?

Holosmos

Ben ce que je veux dire c’est que pour calculer une portion de l’image, tu n’as pas besoin de connaître toute l’image, si ? Ainsi, au lieu de calculer une image de 1 milliard de pixels, tu pourrais d’abord calculer une image de 1 million de pixels, puis relancer du calcul si l’utilisateur demande de zoomer. Ça prendrait moins de place en mémoire. Mais comme tu le mentionnes, tu sembles être bloqué par la technique (raison de plus pour open-sourcé le code).

+0 -0

Ben ce que je veux dire c’est que pour calculer une portion de l’image, tu n’as pas besoin de connaître toute l’image, si ? Ainsi, au lieu de calculer une image de 1 milliard de pixels, tu pourrais d’abord calculer une image de 1 million de pixels, puis relancer du calcul si l’utilisateur demande de zoomer. Ça prendrait moins de place en mémoire. Mais comme tu le mentionnes, tu sembles être bloqué par la technique (raison de plus pour open-sourcé le code).

Initialement mon programme faisait ça : une fenêtre où on pouvait se balader.

C’était très chouette mais j’avais envie de produire une image très grosse une "bonne fois pour toute" :)

Pour l’open-source, je vais m’y mettre. Je veux au moins nettoyer un peu mon code, j’aurai aimé le réécrire plus proprement.

(Soyons fous, si tu as pu faire 1 milliard sur un PC de monsieur-tout-le-monde c’est qu’on peut faire énormément plus :-) )

Il a fait ça sur un seul CPU avec une fréquence plutôt basse, avec un bon GPU on peut facilement gagner un facteur 1000 je pense, et si tu t’autorises un temps de calcul plus long genre une semaine, tu rajoutes encore un facteur 100 par-dessus. Ça donne envie de relever le challenge d’un facteur 106, ça s’appellerait le projet petarabbit.

I don’t mind that you think slowly, but I do mind that you are publishing faster. – W. Pauli

+11 -0

J’aurais bien aimé trouvé dans ton billet quelques informations sur le temps de calcul pour générer les images, avec quel ordinateur et le langage utilisé. Un lien vers le code source serait un must-have !

Après, ne serait-il pas plus intéressant de générer l’image de façon intéractive (c’est à dire en zoomant sur la figure) ? Dans le cadre des fractales de Julia, il me semble que l’on peut connaître la valeur d’un pixel de façon locale, donc pas besoin de connaître tous les points de l’image.

Saroupille

Le code est , il faut compiler avec SFML pour la gestion de la fenêtre et lodpng pour la création de la photo

C’est encore un peu le bordel dans le main … il faut juste penser à changer le chemin du fichier pour la sauvegarde de la photo

Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte