AP – fractale de Mandelbrot

On va essayer dans cette séance de générer des images de la fractale de Mandelbrot.

Avec des parties réelles allant de -2 à 0,6 et des parties imaginaires  allant de -1 à 1 :

cm 2019-11-18 mandelbrot_large

en niveaux de gris.

Un zoom pour des parties réelles allant de -0,64 à -0,44 et des parties imaginaires  allant de 0,5 à 0,7 :

cm 2019-11-18 mandelbrot_zoom

Que c’est beau !

Un point d’affixe c \in \mathbb{C} donnée appartient à l’ensemble de Mandelbrot si la suite \left(z_n \right) est bornée avec : \left\lbrace \begin{array}{l}z_0 = 0\\z_{n+1}=z_n^2+c\end{array}\right.

Pour notre programme, on va considérer que si |z_n|\leqslant 2~~\forall n \leqslant 254, n entier naturel, alors le point d’affixe c appartient à l’ensemble de Mandelbrot et sera représenté en noir.

Si pour un entier naturel n_0 \leqslant 254, on a |z_{n_0}|>2 alors c n’appartient pas à l’ensemble de Mandelbrot et sera représenté en gris, de plus en plus blanc plus qu’on dépasse 2 en module rapidement.

Puisque n_0 = 0 représenterait du blanc et 255 du noir, le niveau de gris pour n_0 \leqslant 254 est alors \texttt{255}-n_0.

On encode tout ça dans un fichier pgm portable graymap.

Les tableaux des deux groupes :

Lors des groupes 1 et 2, on a généré ceci (avec une tentative de couleur aussi) :

Les programmeurs (ISNiens ou pas) obtiendront s’ils le souhaitent bien plus joli encore… un petit voyage ? On zoome sur ce gif issu de Wikipedia vers la valeur de c = -0,743643887037151 + 0,13182590420533\text{i}, à travers nombre de motifs  caractéristiques.

Le rapport de grossissement entre la dernière et la première image est d’environ 60 milliards…

Le code utilisé :

def cree_image_pgm(larg, haut, pixels):
    """ S'il reçoit une liste de larg * haut niveaux de gris dans pixels,
    enregistre "cm 2019-11-18 image avec repère.pgm" dans le même dossier"""

    # ouverture du fichier en écriture
    f = open("cm 2019-11-18 mandelbrot.pgm",'w')

    # entête
    f.write('P2\n')
    f.write(str(larg) + ' ' + str(haut) + '\n')
    f.write("255\n")

    # niveaux de gris
    for i in range(len(pixels)):
        f.write(str(pixels[i]) + ' ')

    # fermeture
    f.close()

def pixel_vers_complexe(xp, yp, largeur, hauteur, xmin, xmax, ymin, ymax):

    # calcul de la partie réelle
    partie_reelle = xmin + (xp / largeur) * (xmax - xmin)

    # idem avec le complexe
    partie_imaginaire = ymax - (yp / hauteur) * (ymax - ymin)

    # on renvoie le complexe correspondant
    return complex(partie_reelle, partie_imaginaire)

def niveau_de_gris_pour(c):
    """
        c un complexe
        Préconditions : aucune
        Cette fonction calcule la valeur de la fractale de Mandelbrot à partir de c
        La valeur de retour de cette fonction est un entier compris entre 0 et 255
    """

    # initialisation
    n = 255
    z = 0

    # traitement avec calcul des z (zn) tant qu'on ne dépasse pas 2 en module
    # (au passage le module s'écrit abs(z) pour le type complex de python)
    # et tant qu'on ne dépasse pas 256 itérations

    while abs(z) <=  2 and n > 0 :

        # n baisse
        n = n - 1

        # c a été "envoyé" à la fonction
        z = z ** 2 + c

    # on renvoie le niveau de gris entre 255 et zéro
    return n

def cree_liste_pixels(xmin, xmax, ymin, ymax, largeur, hauteur):
    """ parcourt les pixels, calcule le complexe correspondant,
    calcule le niveau de gris correspondant, et le rajoute à une liste
    qu'on renvoie à la fin"""    

    # liste vide
    liste=[]

    # On parcourt les pixels
    for yp in range(hauteur) :
        for xp in range(largeur) :

            # On calcule le complexe correspondant
            c = pixel_vers_complexe(xp, yp, largeur, hauteur, xmin, xmax, ymin, ymax)

            # On rajoute le niveau de gris pour ce complexe c à la liste
            liste.append(niveau_de_gris_pour(c))

    # On renvoie la liste
    return liste

largeur = 1300
hauteur = 1000
xmin = -2
xmax = 0.6
ymin = -1
ymax = 1

# liste des niveaux de gris
liste = cree_liste_pixels(xmin, xmax, ymin, ymax, largeur, hauteur)

# enregistrement de l'image
cree_image_pgm(largeur, hauteur, liste)

4 réflexions au sujet de « AP – fractale de Mandelbrot »

  1. Bonsoir,
    Il me semble qu’il y a un petit bug dans le code car dans la ligne 47 après le while il n’y a aucun signe.
    Bonne soirée.

    • Bonjour,
      Oui, les « crocodiles » 😉 < et > ne passent pas toujours car wordpress les interprète comme des balises html insidieuses…
      La bonne version était bien sur le TBI joint, qu’on peut retrouver dans l’article ou (sur le dernier tableau).
      J’arrange ça, merci le non-espion !
      Bonne journée

N'hésitez-pas à poser une question, ou faire avancer le schmilblick

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur la façon dont les données de vos commentaires sont traitées.