Génération de fractales (Mandelbrot, Julia)

Lesmathscestchic

Bonjour à tous, 
Je me suis amusé à générer certaines fractales (ensembles de Julia, de Mandelbrot, et d'autres trucs) par ordinateur. Voici ce que ça donne :

Je me suis retrouvé confronté à certaines limites (notamment par rapport à la pixellisation), mais mon plus gros questionnement est par rapport au fait que les suites de points restent ou non bornées. En effet pour générer ce genre de fractales, on prend $z_0$ et $c$ dans le plan complexe, on pose $f:z\rightarrow z^2+c$, et on définit par récurrence $z_{n+1}=f(z_n)$. Il s'agit alors de se demander si la suite $(z_n)$ est bornée, et par ordinateur, ça se fait empiriquement. Du coup, j'ai fait des tests, et j'ai des figures qui correspondent à ce que je suis censé trouver (pour Mandelbrot notamment), mais impossible de vérifier à quel point les détails correspondent (et une fractale, c'est plein de détails).
Dans l'idée, pour vérifier si c'est borné, je compose par $f$ un certain nombre de fois (100) et je regarde si ça dépasse un certain module (5). À noter que je pourrais changer ces valeurs, mais que je ne sais pas vraiment ce qui serait pertinent, et je suis toujours limité par la puissance de mon PC. J'attribue ensuite du noir si c'est "borné" puis un dégradé de couleurs en fonction de la vitesse que ça a mis à dépasser la borne si ce n'est "pas borné".

Du coup, je me demande si c'est possible de déterminer "mieux" le fait de rester borné ou encore d'évaluer mieux "la vitesse à laquelle ça diverge" si ce n'est pas borné. De plus, je me demande si c'est pertinent de générer ces fractales de cette façon là. Qu'en pensez-vous ?
Merci d'avance
Lesmathscestchic

AD

Bonsoir
En ce qui concerne Mandelbrot, on montre que si le module de l'itération dépasse 2, alors la suite d'itérations diverge.

Le principe est donc de tester à chaque itération le module obtenu, et dès qu'on dépasse 2, on arrête et on colorie le pixel en fonction du nombre d'itérations atteintes modulo le nombre de couleurs choisies.
En revanche, tu abandonnes le rebouclage et tu mets le pixel en noir, si tu dépasses 100 itérations, par exemple, ou beaucoup plus suivant la position où tu travailles, l'échelle et la précision que tu veux obtenir.
Cela fait des rayures de couleurs dégradées dans les vallées de divergence.
Alain

Lesmathscestchic

Merci pour l'indication sur le module : c'est tout bête et ça va me permettre d'optimiser un peu.

nicolas.patrois

Un bon logiciel pour ça : fraqtive.

Homo Topi

@Lesmathscestchic tu utilises quel programme pour générer ces graphes ?

Lesmathscestchic

Alors, c'est vraiment pas sorcier : j'utilise python, et j'exporte des images au format PPM (c'est pas compliqué, c'est du pixel par pixel avec les trois canaux par pixel). Il suffit de créer un tableau qui contient la couleur de chaque pixel, puis de convertir le tableau en PPM (j'ai codé une petite fonction pour ça, mais c'est vraiment pas sorcier).
Le code pour Mandelbrot par example :

import math
from random import randint

def f(z,c) :
    return z**2+c

def conv(z0,c):
    y=z0
    for k in range(100):
        y=f(y,c)
        if abs(y)>5 :
            return k
    return 0

def tab(p,Nx,Ny,z0):
    T=[[0]*Nx for k in range(Ny)]
    for a in range(Nx) :
        for b in range(Ny):
            c=-(Nx*p)/2+p*a+(-(Ny*p)/2+p*b)*1j
            T[b][a]=conv(z0,c)
    return T

def exp_img(p,Nx,Ny,k):
    T=tab(p,Nx,Ny,0)
    texte="P3\n"+str(Nx)+" "+str(Ny)+"\n255\n"
    f=couleur_aleat()
    for b in range(Ny):
        for a in range(Nx):
            if T[b][a]==0 :
                texte+="0 0 0\n"
            else :
                tr=f[T[b][a]]
                texte+=str(tr[0])+' '+str(tr[1])+' '+str(tr[2])+'\n'
    with open("Mandelbrot2/"+str(k)+".ppm","w") as destination :
        destination.write(texte)

def couleur_aleat():
    tab=[(randint(0,255),randint(0,255),randint(0,255))]
    for k in range(1,100):
        tab.append((max(0,min(tab[k-1][0]+randint(-20,20),255)),max(0,min(tab[k-1][1]+randint(-20,20),255)),max(0,min(tab[k-1][2]+randint(-20,20),255))))
    return tab

for k in range(0,50) :
    exp_img(0.002,2800,1400,k)

nicolas.patrois

Pour exporter les images, tu peux le faire avec PIL, ça marche aussi bien.

Lesmathscestchic

Bonjour à tous. J'ai continué un peu mes générations de fractales. En particulier, j'ai fait ça : 

Lesmathscestchic

Pour ceux qui veulent en savoir un peu plus sur comment je fais ça concrètement, j'ai fait une vidéo explicative dans le cas de l'ensemble de Mandelbrot.

[Benoît Mandelbrot (1924-2010) mérite bien sa majuscule. AD]

etanche

Pourrais-tu faire le lapin de Douady ? Merci 

Lesmathscestchic

Voili-voilou : 

Lesmathscestchic

Et une dernière pour la route : un bébébrot : 

raoul.S

Très jolie celle-ci. J'apprécie particulièrement les couleurs, même si j'aurais essayé avec du rouge beaucoup plus foncé à la place du "rose" au bord de l'image.

Lesmathscestchic

L'aléatoire fait bien les choses...

Lesmathscestchic

Bonjour tout le monde. Vous avez pu voir ci dessus, un satellite de l'ensemble de Mandelbrot. Mais dès que je zoome un peu trop, mon PC n'a plus la puissance pour itérer suffisamment loin de façon à ce que la frontière de l'ensemble "reste la bonne".
Y auraient-ils parmi vous des personnes qui auraient des conseils à me donner pour optimiser ma génération ?

Math Coss

Tu pense qu'ils y auront des réponses ?

Médiat_Suprème

Un moyen efficace consiste à ne faire de calculs que sur des entiers (comme le fait le programme Fractint)

raoul.S

Lesmathscestchic a dit :

Mais dès que je zoome un peu trop, mon PC n'a plus la puissance pour itérer suffisamment loin de façon à ce que la frontière de l'ensemble "reste la bonne".

Je ne comprends pas trop le problème. Quand tu zoomes le nombre de pixels sur ton image reste le même et il ne devrait pas y avoir de problèmes à moins que quelque chose m'échappe. Poste ton code pour voir (sans garanties...)

Médiat_Suprème

Le problème ne vient sans doute pas des pixels, mais de la limitation dans la précision des calculs