Skip to content

Fractal – Rendu

February 18, 2007

Aujourd’hui nous allons regarder comment générer ce genre d’image les doigts dans le nez, ou ailleur, enfin les doigts quelque part (non pas là bande de pervers).

Image d'un budha brot foiré

Pour les fractals opérants sur le plan complexe, il existe principalement 2 techniques de rendu : la méthode qu’on appellera d’itération et la méthode Buddah ou de densité. Attention je ne parle d’ici que de fractal défini par une suite.

Formules utilisées

Dans la suite de l’article, nous allons utiliser la formule de base pour un fractal de Mandelbrot. Globalement un fractal ressemble à 2 gros cercles (oui très globalement) et est tiré de la formule suivante :

zn+1 = z2 + c

Forme globale d'un fractal de mandelbroot

z & c étant des nombres complexes. Pour un rendu de mandelbroot z0 est initialisé à 0 et c représente un point du plan. Pour un rendu de julia, c est un constante à determiner et z correspond au point actuel du plan complexe. Le comportement global, c’est que si le point z est à l’intérieur des 2 sphères, alors la suite aura tendance à rester dans la partie noire. Au contraire, si le point de départ se situe en dehors, la suite va tendre vers l’infini.

Iteration générale blabla

Donc dans l’image à gauche, le trai en bleu représente un point prit en déhors de l’ensemble de mandelbroot, qui va très rapidement vers l’infini. Le trai blanc représente un point prit dans l’ensemble et qui reste dans ce même ensemble. Attention, c’est une représentation pour se faire une idée, elle n’est absolument pas correcte mathématiquement.

Technique d’itération

C’est le principe de base pour le rendu de fractal, le premier a avoir été mit au point. L’idée est d’itérer la suite un grand nombre de fois et quand la norme de nombre complexe dépasse 2, d’arrêter l’iteration et de mettre le nombre d’itération avant dépassement à la place du pixel. On obtient donc une image en niveau de gris. Cette méthode peut être très facilement être mit en parallèle, vu que chaque pixel est traité independamment. C’est la méthode qui a été utilisé dans ce post, en utilisant un maximum les capacités de parallélisme des cartes graphiques actuelles. Je vais poster la source dans un prochain post.

On remarquera que plus le nombre d’itération est grand, plus le fractal final sera fin et possedera des niveaux de gris. Pour colorer le fractal, il suffit de le prendre un nombre d’itération et de lui associer une couleur, tout simplement.

Technique par densité

C’est une technique plus évolué, qui a été utilisé par l’image en haut du post. Attention cependant, l’image en haut du post n’a pas bénéficié d’assez de calcul pour avoir un rendu de haute qualité. L’idée de départ est de rendre le pixel plus blanc à chaque fois qu’un point itère sur un pixel. Vu que ma phrase est claire comme le pétrole de l’Erika, voici un pseudo-algorithme plus simple.

 Soit z un point complexe Pour chaque itération du point courant     Rendre le point z de l'image un peu plus blanc     z <- z * z + c fin Pour 

rendu foiré

Voilà pour l’idée, maintenant ne faites pas comme moi, ne vous dites pas, je fait l’algorithme pour chaque point de l’image et basta, tout ce que vous pouvez gagner c’est une image toute moche (genre l’image à gauche là). La solution qui marche bien pour ce genre de rendu est d’utiliser une méthode dite de Monte Carlo. On choisi un grand nombre de points au hasards et on itère comme des brutes sur ces points. L’image du haut du post doit contenir plus de 10 Millions de points déjà, et le rendu n’est pas tip-top. Donc ça demande énormement de calculs.

Maintenant la méthode d’itération donnée plus haut n’est pas complète, nous devons exclure tous les points appartenant à l’ensemble de Mandelbrot, car ils auraient la facheuse tendance à rendre le centre vraiment plus blanc ce qui est un peu la méthode classique, dont le résultat ici ne nous intéresse pas. Pour cela nous fixons une limite (genre 200 itérations) pour voir si le point se rapproche de l’infini (ou d’une valeur suffisemment grande). Si le point n’a pas dépassé la limite au bout de 200 itérations, nous abandonons tous les calculs pour ce point. Si il dépasse la limite avant, nous augmentons la luminosité des pixels visités pour chaque pixel visité pendant les itérations.

Présentation du programme de génération dans MassiveStream

Avant de pouvoir afficher l’image, nous devons repasser les valeurs dans un domaine représentable par nos écrans, qui n’ont que 256 niveaux de gris affichable (je ne parle de la couleur ici, vu qu’on fait un rendu en niveau de gris). Pour cela l’image doit passer par une normalisation qui fait revenir toutes les valeurs dans l’interval [0;1]. Ensuite il est de très bon goût d’appliquer une correction gamma ( le ^ ~0.5 dans le programme ), afin de faire mieux ressortir les valeurs basses de l’image. Pour finir une bonne ptite multiplication des familles pour atérir dans l’interval affichable de [0;255]. Cette partie est prit directement en charge par le module IO/ImgOut

La suite

Au moment où j’écrit ce post, mon processeur est gentiment en train de me génerer un fractal par technique d’itération sur la formule de Julia. Le rendu est paramétré pour tirer 10 Milliards de points pour creer une image en 1600 * 1200 (une grosse image donc) et avec une limite d’itération de 1000 fois. Le rendu dure déjà depuis 3h et a encore besoin de 2 bonnes heures pour se terminer (oui c’est long).

Advertisements

From → General

Leave a Comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: