Fractale de mandelbrot et julia [djgpp]

Télécharger le projet
Commenter

Description

Un programme qui dessine une fractale de Mandelbrot ou de Julia. Possibilité d'enregistrer une image au format .bmp, voir la capture pour quelques exemples générés avec le programme.

Pour compiler le programme, utilisez la ligne de commande :
gcc mandelbrot-julia.c gfx.c mouse.c bmp.c -o mandelbrot-julia.exe

Certaines fonctions que j'ai implémentées ne sont pas utilisées, par exemple le programme n'a pas besoin d'ouvrir un .bmp (seulement de l'enregistrer), ni de laisser l'utilisateur entrer un nombre réel (seulement un nombre entier est nécessaire), ni d'avoir un appel à une fonction pour afficher la souris. J'ai choisi de ne pas effacer ces fonctions de la source, même si elles ne sont pas vraiment nécessaires...

Le mode graphique utilisé est le VGA 13h, c'est pas très moderne ni très beau, mais ça a le mérite d'être très simple.

Pour ceux qui ne veulent pas compiler ou n'ont pas DJGPP, vous pouvez essayer le programme ici :
http://gcheese.free.fr/prog/mandelbrot-julia.exe

Source / Exemple : 


Voir le fichier zip pour le code source, ici j'explique en gros comment generer une fractale pour ceux qui ne le sauraient pas.

Premiere chose a savoir pour vouloir generer une fractale : les operations sur les nombres complexes.

Un nombre complexe est un nombre de la forme z = a + bi, ou i est un nombre tel que i^2 = -1 (en d'autre mot, i est la racine carree de -1, c'est donc un nombre 'imaginaire')

A partir de la toutes les operations se font normalement, mais en tenant compte du fait que i^2 = -1

exemple :

(a + bi) + (c + di) = (a+c) + (b+d)i

(a + bi) * (c + di) = (ac-bd) + (ad+bc)i

Ensuite, les fractales de Mandelbrot et de Julia sont bases sur une seule ridicule petite formule :

z_n+1 = z_n^2 + c

(ne pas oublier que c et z sont des nombres complexes !)

Si je prend z_0=a+bi et c=c+di, j'ai donc :

z_0=a+bi
z_1=(a+bi)^2+(c+di)
z_2=((a+bi)^2+(c+di))^2+(c+di)
z_3=(((a+bi)^2+(c+di))^2+(c+di))^2+(c+di)
etc...

Les nombres complexes sont donc d'une certaine maniere des couples de nombres 'normaux'.
Vu qu'on a donc deux nombres, on peut representer les nombres complexes sur un plan, le nombre z=a+bi sera le point (a,b)

Maintenant, on se rend compte que selon la valeur de depart de z_0, la plupart des z_n deviennent de plus en plus grand jusqu'a l'infini, mais que certains au contraire convergent...
Ces valeurs de depart z_0 qui donnent des z_n convergents appartiennent a l'ensemble de Mandelbrot, c'est notre fractale.

Cependant on ne peut evidemment pas calculer les z_n jusque l'infini pour savoir s'ils convergent ou pas... mais on peut etre sur que si la valeur absolue d'un nombre est plus grande que 2, alors il va diverger.
La valeur absolue d'un nombre complexe z=a+bi est |z|=sqrt(a^2+b^2), en fait c'est la distance de (a,b) a (0,0)

Donc je devrai seulement calculer les z_n tant que (a^2+b^2)<4 (mais avec un nombre d'iterations maximum, sinon les nombres appartenant a la fractale provoqueront une boucle infinie !)

Il reste a colorier differemment les points z_0 selon qu'ils divergent ou convergent. Generalement, on choisir de colorier en noir les z_0 convergents et d'attribuer une couleur au z_0 divergents selon le nombre d'iterations necessaires avant qu'ils se mettent a grandir irremediablement.

Et par magie (et ca je ne sais pas vraiment l'expliquer), la fractale de Mandelbrot va apparaitre.

Le c de l'equation z_n+1 = z_n^2 + c est en fait une 'perturbation', normalement on met le c a zero, autrement la fractale sera un peu 'deformee'.

Quant a la fractale de Julia c'est presque pareil, a la difference pres que z_0 contiendra une constante et c contiendra le point.
Ce qui est interessant c'est que les constantes z_0 les plus interessantes sont celles qui bordent la fractale de Mandelbrot... c'est pourquoi dans le programme on peut voir un 'apercu' du Julia 'associe' au Mandelbrot.

Le seul probleme est donc qu'il est parfois un peu lent de calculer une fractale... en effet, si je veux une image de dimensions x*y, avec une iteration maximum de i, alors il faudra executer la formule x*y*i fois (et apres ça s'occuper du coloriage, etc...).

PS : normalement on ecrit 'fractale', c'est un mot féminin, en tout cas Benoit Mandelbrot en expliquant sa theorie a insiste pour que 'fractale' soit utilise au feminin... cependant on le voit souvent ecrit au masculin 'un fractal'.

Conclusion :


Problèmes connus :
- Lors de l'enregistrement d'un .bmp, si on choisit un grand nombre d'iterations maximum, on aura peu de couleurs différentes. Ça dépend du mode de coloriage choisi, mais normalement le programme essaye de s'arranger pour que toute la palette des couleurs soit présente. Mais seulement pour un grand nombre d'itérations, on aura souvent une petite centaine de points de couleurs 200-255, et des milliers de points pour les couleurs 2-50. On pourrait arranger cela en implémentant un algorithme qui s'arrange non pas pour que toute la palette soit utilisée, mais pour que toutes les couleurs soit présentes en proportions équivalentes. Mais c'est beaucoup de boulot (compter les points de même itérations, etc...) pour pas grand chose, j'ai donc choisi de laisser ça comme ça.
- Quand on zoome trop, au bout d'un moment la fractale se déforme, puis n'est même plus affichée. L'explication réside dans le fait que le zoom est en fait exprimé sous la forme du "rayon" (la taille) de l'image qui doit être affichée. Plus la variable "radius" est petite plus le zoom est fort, mais on ne peut pas mettre une valeur aussi petite qu'on veut dans une variable "double" ! Un moment le nombre sera si petit qu'il sera considéré comme nul, ce qui fait planter la génération de la fractale. Là encore, les solutions possibles demandent trop de travail pour pas grand chose...
- Sinon c'est tout, quelques petits bugs d'affichage de temps en temps peut-être, mais rien de grave.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.