Création d'une image en Python

Cette activité a pour but d'apprendre à créer des images numériques de toutes sortes en Python, en donnant des programmes modifiables afin de personnaliser les images (motifs et couleurs).

Commençons par dessiner une image "surfacique", c'est-à-dire une image où chaque pixel possède une couleur donnée par une équation en fonction des coordonnées x et y du pixel.

Voici un premier exemple dans lequel l'équation de la couleur est n=x*cos(x)+y*sin(y) :

# ##########################################################################
# Dessine une image surfacique pixel par pixel dans une fenêtre Matplotlib #
# Programme réalisé le 01 novembre 2022 par Jean-Christophe MICHEL         #
# www.gecif.net                                                            #
# ##########################################################################

import matplotlib.pyplot as plt
from math import *

x_min=-40
x_max=40
y_min=-40
y_max=40

# résolution de l'image :
res_x=500
res_y=500

tab = []

for py in range(1,res_y+1):
        ligne=[]
        for px in range(1,res_x+1):
                x=x_min+px*(x_max-x_min)/res_x
                y=y_max-py*(y_max-y_min)/res_y

                # pour modifier l'image il suffit de changer l'équation de n en fonction de x et de y :
                n=x*cos(x)+y*sin(y)

                ligne.append(n)

        tab.append(ligne)

# crée une figure dans la fenêtre :
fig=plt.figure(1, figsize=(8, 8))

# crée un axe dans la figure :
ax=fig.add_subplot(1,1,1)

# n'affiche pas les graduations sur les axes :
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)

# agrandit le repère à toute la surface de la figure :
plt.gcf().subplots_adjust(left = 0, bottom = 0, right = 1, top = 1, wspace = 0, hspace = 0)

# affiche l'image :
ax.imshow(tab)
plt.show()

Télécharger ce programme surfacique_base.pyw

Et voici l'image surfacique obtenue :

En modifiant l'équation de n en fonction de x et de y on change le motif de l'image surfacique. Voici quelques exemples à tester :

n=x*cos(y)+y*sin(x)
n=(x+y)*cos(y)*sin(x)
n=x*y*cos(y)*sin(x)
n=x*y*cos(y)**2*sin(x)**2
n=x*cos(x)**2+y*sin(y)**2
n=x*cos(y)**2+y*sin(x)**2
n=(int(x)%7)*cos(x)+(int(y)%11)*sin(y)
n=(int(x)%7)*cos(y)+(int(y)%7)*sin(x)
n=x**2*cos(y)+y**2*sin(x)
n=(x/10)**2+(y/10)**2
n=sin((x/8)**2+(y/8)**2)
n=cos((x/8+y/8)**2)
etc. à vous d'inventer la suite ...

La palette de couleur utilisée par défaut est une palette "arc-en-ciel" allant du bleu au rouge. Pour l'afficher dans une barre verticale, modifions les 2 dernières lignes du programme de base en les remplaçant par :

# affiche l'image :
im=ax.imshow(tab)
# affiche la palette de couleur utilisée dans une barre vertivale :
fig.colorbar(im, ax=ax, extend='min', orientation='vertical')
# met à jour la fenêtre pyplot :
plt.show()

Et voici le résultat avec cette fois l'équation n=x*y*cos(y)**2*sin(x)**2 pour la couleur des pixels :

Télécharger le programme surfacique_2.pyw

Il est tout à fait possible d'utiliser une autre palette de couleur que la palette arc-en-ciel par défaut : il faut alors préciser la palette à utiliser lors de l'appel de la fonction imshow. Voici quelques noms de palette à tester :

Blues
RdBu
OrRd
Reds
CMRmap
Dark2

Affichons par exemple l'image précédente en utilisant la palette de couleur RdBu (allant du Rouge au Bleu). Pour cela on appelle la fonction imshow avec un nouveau paramère cmap précisant le nom de la palette à utiliser :

# affiche l'image :
im=ax.imshow(tab, cmap='RdBu')
# affiche la palette de couleur utilisée dans une barre vertivale :
fig.colorbar(im, ax=ax, extend='min', orientation='vertical')
# met à jour la fenêtre pyplot :
plt.show()

Et voici le résultat :

Remarque : les palettes de couleurs prédéfinies sont des propriétés de l'objet plt.cm. Pour en obtenir la liste on pourra taper dir(plt.cm) dans la console de Pyton.

En voici une liste reconstituée :

liste_palette=['Accent',
'Accent_r',
'Blues',
'Blues_r',
'BrBG',
'BrBG_r',
'BuGn',
'BuGn_r',
'BuPu',
'BuPu_r',
'CMRmap',
'CMRmap_r',
'Dark2',
'Dark2_r',
'GnBu',
'GnBu_r',
'Greens',
'Greens_r',
'Greys',
'Greys_r',
'OrRd',
'OrRd_r',
'Oranges',
'Oranges_r',
'PRGn',
'PRGn_r',
'Paired',
'Paired_r',
'Pastel1',
'Pastel1_r',
'Pastel2',
'Pastel2_r',
'PiYG',
'PiYG_r',
'PuBu',
'PuBuGn',
'PuBuGn_r',
'PuBu_r',
'PuOr',
'PuOr_r',
'PuRd',
'PuRd_r',
'Purples',
'Purples_r',
'RdBu',
'RdBu_r',
'RdGy',
'RdGy_r',
'RdPu',
'RdPu_r',
'RdYlBu',
'RdYlBu_r',
'RdYlGn',
'RdYlGn_r',
'Reds',
'Reds_r',
'Set1',
'Set1_r',
'Set2',
'Set2_r',
'Set3',
'Set3_r',
'Spectral',
'Spectral_r',
'YlGn',
'YlGnBu',
'YlGnBu_r',
'YlGn_r',
'YlOrBr',
'YlOrBr_r',
'YlOrRd',
'YlOrRd_r']

Le programme surfacique_3.pyw tire au hasard une palette parmi les 72 palettes de la liste liste_palette puis affiche l'image surfacique utilisant l'équation n=sin((x/8)**2+(y/8)**2) en précisant le nom de la palette utilisée. Voici quelques résultats :

Télécharger le programme surfacique_3.pyw

Et voici un autre exemple d'image surfacique. Toutes les images suivantes sont en résolution 800x600 pixels et utilisent la palette de couleur CMRmap (sans l'afficher sur l'image).

Cette fois l'équation de n donne une valeur entière (grâce à la fonction int de Python) , mais surtout contient l'opérateur modulo (% en Python) qui permet de régler "le nombre de couleurs" qui sera utilisé dans l'image (donc indirectement le contraste de l'image).

Exemple d'équation : n=int(x*cos(x)+y*sin(y)) % 100

Et voici les résultats pour différentes valeurs du diviseur (% 100, % 50 et % 200) :

n=int(x*cos(x)+y*sin(y)) % 100

n=int(x*cos(x)+y*sin(y)) % 50

n=int(x*cos(x)+y*sin(y)) % 200

On peut aussi modifier l'équation de n. Par exemple tout simplement le produit x*y. Voici 3 exemples avec 3 modulos différents :

n=int(x*y) % 50

n=int(x*y) % 100

n=int(x*y) % 200

Enfin on peut également modifier la taille du zoom. Pour cela on va utiliser un coefficient coeff_zoom afin de multiplier par 2, 4, 5, 10 20, etc. les 4 variables x_min, x_max, y_min et y_max :

coeff_zoom=4
x_min=-4.44350838253174E+0001*coeff_zoom
x_max=4.31538338253302E+0001*coeff_zoom
y_min=-3.29278753690077E+0001*coeff_zoom
y_max=3.27638128689780E+0001*coeff_zoom

Voici quelques exemples :

coeff_zoom=4 et n=int(x*y) % 50

coeff_zoom=10 et n=int(x*y) % 100

coeff_zoom=2 et n=int(x*cos(x)+y*sin(y)) % 100

coeff_zoom=2 et n=int(x*cos(y)+y*sin(x)) % 100

Télécharger le programme surfacique_4.pyw

Voici d'autres palettes de couleurs illustrées (à tester), certaines donnent de très beaux résultats (hsv, prism, ou gist_rainbow par exemple) :

Pour illustrer ces nouvelles palettes de couleurs, nous repartons du programme surfacique_4.pyw mais dans lequel on va décaler les valeurs de base du zoom :

coeff_zoom=2
decalage_x=20
decalage_y=20
x_min=-4.44350838253174E+0001*coeff_zoom+decalage_x
x_max=4.31538338253302E+0001*coeff_zoom+decalage_x
y_min=-3.29278753690077E+0001*coeff_zoom+decalage_y
y_max=3.27638128689780E+0001*coeff_zoom+decalage_y

Voici quelques exemples d'images obtenues :

Éléments principaux du programme :	Image surfacique obtenue :
coeff_zoom=2 decalage_x=20 decalage_y=20 n=int(x*cos(y)+y*sin(x)) % 100 ax.imshow(tab, cmap='gist_rainbow')
coeff_zoom=0.5 decalage_x=80 decalage_y=80 n=int(x*cos(x)+y*sin(y)) % 100 ax.imshow(tab, cmap='rainbow')
coeff_zoom=0.5 decalage_x=80 decalage_y=80 n=int(x*cos(x)**2+y*sin(y)**2) % 100 ax.imshow(tab, cmap='hsv')
coeff_zoom=1/4 decalage_x=0 decalage_y=0 n=int((x*cos(x)+y*sin(y))**2) % 100 ax.imshow(tab, cmap='prism')
coeff_zoom=1/8 decalage_x=10 decalage_y=10 n=int((x*cos(y)+y*sin(x))**2) % 50 ax.imshow(tab, cmap='jet')
coeff_zoom=1/4 decalage_x=10 decalage_y=10 n=int(x**2*cos(y)+y**2**sin(x)) % 50 ax.imshow(tab, cmap='brg', interpolation='none')

Voici d'autres équations donnant une valeur à n en fonction des coordonnées x et y de chaque pixel, à tester pour générer de nouvelles images surfaciques :

n=(255*(cos($y)*sin(x)+1)) % 255
n=(255*(cos(y)+sin(x)+1)) % 255
n=(255*x*(cos(y)*sin(x)+1)) % 255
n=(255*y*(cos(y)*sin(x)+1)) % 255
n=(255*(y*(cos(x*x)+1)+x*(sin(y*y)+1))) % 255
n=(255*(y*(cos(x*y)+1)+x*(sin(x*y)+1))) % 255
n=(255*(cos(y)*sin(y)*sin(x)*cos(x)+1)) % 255
n=(255*(cos(y)*sin(y)+sin(x)*cos(x)+1)) % 255
n=(255*(cos(y)*cos(x)+sin(x)*sin(y)+1)) % 255
n=(x*cos(y)) % 255
n=(y*cos(x)) % 255
n=(x**3 + y**3) % 255
n=x*y
n=(y*(x_max-x)*cos(x*y)+x*(y_max-y)*sin(x*y)) % 255
n=(x*cos(y) +y*sin(x) ) % 255
n=(255*(cos(y*sin(x*y)+x*sin(y*x))+1)) % 255
n=(x*x*cos(y) +y*y*sin(x) ) % 255
n=(x*y*cos(y) +y*x*sin(x) ) % 255
n=(x*x*cos(x) + y*y*sin(y) ) % 255
n=(x*x*y*cos(y) +y*y*sin(x) ) % 255
n=(x*y*cos(y) +y*x*x*sin(x) ) % 255
n=(x*x*x*cos(x) + y*y*y*sin(y) ) % 255
n=(255*(cos(x*y)+1)) % 255
n=(255*(cos(y*sin(x)+x*sin(y))+1)) % 255
n=(255*(sin(x)+1)) % 255
n=(255*(sin(y)+1)) % 255
n=(255*(cos(y)*sin(x)+1)) % 255
n=(255*(cos(y)+sin(x)+1)) % 255
n=(255*(cos(y*x)*sin(x*y)+1)) % 255
n=(255*(cos(y)*sin(x)+1)*(cos(y)+sin(x)+1)) % 255
n=(255*(y*cos(y)+x*sin(x)+1)) % 255
n=(255*(y*cos(x)+x*sin(y)+1)) % 255
n=(255*((cos(x)+1)-(sin(y)+1))) % 255
n=(255*((cos(x)+1)+(sin(y)+1))) % 255
n=(255*(cos(y+x)*sin(x*y)+1)) % 255
n=(255*(y*(cos(x*y)+x*sin(x*y)))) % 255
n=127*sin((px/res_x)*6.2831853*echelle)+128
n=127*cos((px/res_x)*6.2831853*echelle)+128
n=127*cos((py/res_y)*6.2831853)+128
n=127*sin((py/res_y)*6.2831853)+128
n=(py/res_y)*255
n=(px/res_x)*255
n=(px/res_x)*128+(py/res_y)*127
n=127*sin((px/res_x)*3.14159265)+128
n=127*cos((px/res_x)*3.14159265)+128
n=127*cos((py/res_y)*3.14159265)+128
n=255*cos(x*y+x*y)
n=255*cos(x*x+y*y)
n=255*sin(x*x+y*y)
n=255*sin(x*y+y*x)
n=127*sin((px/res_x)*6.2831853*echelle)+128
n=127*cos((px/res_x)*6.2831853*echelle)+128
n=127*cos((py/res_y)*6.2831853*echelle)+128
n=127*sin((py/res_y)*6.2831853*echelle)+128
n=(py/res_y)*255
n=(px/res_x)*255
n=(px/res_x)*128+(py/res_y)*127
n=127*sin((px/res_x)*6.2831853*echelle)+128*sin((py/res_y)*6.2831853*echelle)
n=(255*(cos(x*y)+1)) % 255
n=(255*(cos(y)*sin(x)+1)) % 255

Remarques concernant ces 60 nouvelles équations de n :

• les coefficients 255 et 127 permettent de limiter le nombre de couleurs utilisées dans l'image et peuvent être remplacer par d'autres valeurs (à tester)
• la variable echelle est un entier entre 1 et 30 (à tester également)
• évidemment ces équations ne donneront de belles images surfaciques seulement si le zoom est correctement configurer : valeurs des 4 variables x_min, x_max, y_min et y_max à rechercher ...

Les valeurs de base peuvent être un des 3 cas suivants :

x_min=-50
x_max=50
y_min=-50
y_max=50

x_min=-25
x_max=25
y_min=-25
y_max=25

x_min=-12.5
x_max=12.5
y_min=-12.5
y_max=12.5

Pour visiter une galerie de plus de 10 000 images surfaciques utilisant certaines de ces 60 équations, cliquez-ici.

Libre à vous maintenant de tester différentes palettes de couleurs et surtout de complexifier l'équation de la couleur des pixels en donnant à la variable n une valeur en fonction des coordonnées x et de y de chaque pixel. La seule limite sera alors votre imagination !

Les ensembles de Julia

Voici le programme en Python qui calcule un ensemble de Julia :

# ########################################################################
# Trace un ensemble de Julia pixel par pixel dans une fenêtre Matplotlib #
# Programme réalisé le 02 novembre 2022 par Jean-Christophe MICHEL       #
# www.gecif.net                                                          #
# ########################################################################

import matplotlib.pyplot as plt
import math

# ensemble de Julia complet :
x_min=-1.55974934894274
x_max=1.73429361977433
y_min=-1.23556315104494
y_max=1.23496907549286

# résolution de l'image :
res_x=640
res_y=480

# calcul du nombre d'itérations en fonction du grossissement :
grossissement=4/(x_max-x_min)
iter_max=int((math.log10(grossissement)/12)*10000+200)

tab = []
pour_cent=0
print("Grossissement : %g" % grossissement)
print("Nombre d'itérations :",iter_max)
print("Progression du calcul de l'image :")

for py in range(1,res_y+1):
        ligne=[]
        if py % (res_y//10)==0:
                pour_cent+=10
                print("%d %% calculé ..." % pour_cent)
        for px in range(1,res_x+1):
                n=0
                x=x_min+px*(x_max-x_min)/res_x
                y=y_max-py*(y_max-y_min)/res_y
                z=complex(x,y)

                # ####################################################################
                # L'ensemble de Julia dépend de la valeur du nombre complexe z2 :
                # ####################################################################

                #z2=complex(-0.0986,-0.65186)
                #z2=complex(0.32,0.043)
                z2=complex(-0.772691322542185,0.124281466072787)
                #z2=complex(-4.05253601070165E-0001,-6.44628651946028E-0001)
                #z2=complex(-8.60671234122251E-0001,2.66206614158146E-0001)
                #z2=complex(3.77390034989716E-0001,1.04280344628515E-0001)
                #z2=complex(1.98028564451152E-0002,6.71022287982223E-0001)
                #z2=complex(-3.07991027828944E-0002,6.98009999570495E-0001)
                #z2=complex(2.99800364173435E-0001,2.33172098636993E-0002)
                #z2=complex(2.93053436276367E-0001,-2.97037776038500E-0004)
                # ####################################################################

                while(abs(z)<2):
                        z=z*z+z2
                        n+=1
                        if n>=iter_max:
                                break
                ligne.append(n)

        tab.append(ligne)

# crée une figure dans la fenêtre et un axe dans la figure :
fig=plt.figure(1, figsize=(6.4, 4.8))
ax=fig.add_subplot(1,1,1)

# n'affiche pas les graduations sur les axes :
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)

# agrandi le repère à toute la surface de la figure :
plt.gcf().subplots_adjust(left = 0, bottom = 0, right = 1, top = 1, wspace = 0, hspace = 0)

# affiche l'image :
ax.imshow(tab, cmap='RdBu', interpolation='none')
plt.show()

Télécharger le programme julia.pyw

Pour obtenir différentes images fractales d'un ensemble de Julia on pourra modifier soit la valeur de z2, soit la palette de couleur, soit les deux (sur les lignes en rouge dans le programme ci-dessus).

Et voici quelques exemples d'ensembles de Julia, utilisant chacun une valeur précise pour le nombre complexe z2 et une palette de couleur particulière :

z2=complex(-0.772691322542185,0.124281466072787) avec la palette RdBu :	z2=complex(-0.7927,0.1609) avec la palette Greys :
z2=complex(-1.1380,0.2403) avec la palette BuPu :	z2=complex(-0.1225,0.7449) avec la palette Reds_r :
z2=complex(-0.3380,-0.6230) avec la palette YlOrBr :	z2=complex(0.32,0.043) avec la palette PuBuGn :
z2=complex(-0.0986,-0.65186) avec la palette RdYlGn_r et iter_max=1000 :	z2=complex(-4.05253601070165E-0001,-6.44628651946028E-0001) avec la palette PuOr_r :
z2=complex(-8.60671234122251E-0001,2.66206614158146E-0001) avec la palette Reds :	z2=complex(3.77390034989716E-0001,1.04280344628515E-0001) avec la palette Paired_r :
z2=complex(1.98028564451152E-0002,6.71022287982223E-0001) avec la palette RdGy_r :	z2=complex(-3.07991027828944E-0002,6.98009999570495E-0001) avec la palette PiYG_r :
z2=complex(2.99800364173435E-0001,2.33172098636993E-0002) avec la palette Spectral :	z2=complex(2.93053436276367E-0001,-2.97037776038500E-0004) avec la palette CMRmap_r :

Pour voir des ensembles de julia en mouvement, cliquez ici.

L'ensemble de Mandelbrot

Voici le programme de base qui calcule et affiche l'ensemble de Mandelbrot :

# ############################################################################
# Trace l'ensemble de Mandelbrot pixel par pixel dans une fenêtre Matplotlib #
# Programme réalisé le 03 novembre 2022 par Jean-Christophe MICHEL           #
# www.gecif.net                                                              #
# ############################################################################

import matplotlib.pyplot as plt
import math

# Ensemble de Mandelbrot complet :
x_min=-2.61458333330719
x_max=1.33333333332000
y_min=-1.56250000000000
y_max=1.39843749997039

# résolution de l'image :
res_x=640
res_y=480

# calcul automatique du nombre d'itérations en fonction du zoom :
grossissement=4/(x_max-x_min)
iter_max=int((math.log10(grossissement)/12)*10000+200)

tab = []
pour_cent=0
print("Grossissement : %g" % grossissement)
print("Nombre d'itérations :",iter_max)
print("Progression du calcul de l'image :")

for py in range(1,res_y+1):
        ligne=[]
        if py % (res_y//10)==0:
                pour_cent+=10
                print("%d %% calculé ..." % pour_cent)
        for px in range(1,res_x+1):
                n=0
                x=x_min+px*(x_max-x_min)/res_x
                y=y_max-py*(y_max-y_min)/res_y
                z=complex(x,y)
                z2=z
                while(abs(z)<2):
                        z=z*z+z2
                        n+=1
                        if n>=iter_max:
                                break
                ligne.append(n)

        tab.append(ligne)

# crée une figure dans la fenêtre et un axe dans la figure :
fig=plt.figure(1, figsize=(6.4, 4.8))
ax=fig.add_subplot(1,1,1)

# n'affiche pas les graduations sur les axes :
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)

# agrandi le repère à toute la surface de la figure :
plt.gcf().subplots_adjust(left = 0, bottom = 0, right = 1, top = 1, wspace = 0, hspace = 0)

# affiche l'image :
ax.imshow(tab, cmap='PuBuGn', interpolation='none')
plt.show()

Télécharger le programme mandelbrot.pyw

Voici le résultat de ce programme : on obtient l'ensemble de Mandelbrot complet :

Ensemble de Mandelbrot complet (200 itérations)

Ensemble de Mandelbrot complet (avec 40 itérations seulement et la palette RdBu)

Pour obtenir un très grand nombre d'images fractales toutes différentes, il faut effectuer des zooms sur les frontières de l'ensemble de Mandelbrot. Pour cela il faut modifier les valeurs des 4 variables x_min, x_max, y_min et y_max en rouge dans le programme ci-dessus.

On pourra également modifier la palette de couleur utilisée lors de l'appel de la méthode imshow qui affiche l'image, ou encore forcer le nombre d'itérations avec la variable iter_max.

Et voici quelques exemples d'images fractales correspondant à un zoom dans l'ensemble de Mandelbrot. Les dimensions du zoom (valeur des 4 variables x_min, x_max, y_min et y_max), le nombre d'itérations (variable iter_max) ainsi que la palette de couleur utilisée sont précisé pour chaque image :

Pour explorer l'ensemble de Mandelbrot, cliquez-ici. Dans l'explorateur de l'ensemble de Mandelbrot, chaque image porte un numéro précis permettant de l'identifier.

Le programme suivant calcule la taille du zoom (valeur des 4 variables x_min, x_max, y_min et y_max) en fonction du numéro de l'image :

# ############################################################################
# Ce programme zoom.pyw calcule les coordonnées d'une image correspondant à  #
# un zoom dans l'ensemble de Mandelbrot en fonction du numéro de l'image     #
# donné par l'explorateur de l'ensemble de Mandelbrot sur Gecif.net          #
#                                                                            #
# Programme réalisé le 31 octobre 2022 par Jean-Christophe MICHEL            #
# www.gecif.net                                                              #
# ############################################################################

def colonne(i):
        # cette fonction renvoie la colonne (entre 0 et 3) de la portion i (0<=i<=15)
        return i % 4

#****************************************************************************

def ligne(i):
        # cette fonction renvoie la ligne (entre 0 et 3) de la portion i (0<=i<=15)
        if i in [0,1,2,3]:
                return 0
        if i in [4,5,6,7]:
                return 1
        if i in [8,9,10,11]:
                return 2
        if i in [12,13,14,15]:
                return 3

#****************************************************************************

# Ensemble de Mandelbrot complet :
x_min=-2.61458333330719
x_max=1.33333333332000
y_min=-1.56250000000000
y_max=1.39843749997039

image="5FD76"
niveau=len(image)-1
largeur_x=(x_max-x_min)/4
largeur_y=(y_max-y_min)/4
origine_x=x_min
origine_y=y_min

for i in range(niveau):
        c=image[i]
        origine_x=origine_x+largeur_x*colonne(int(c,16))
        origine_y=origine_y+largeur_y*ligne(int(c,16))
        largeur_x=largeur_x/4
        largeur_y=largeur_y/4

c=image[-1]
x_min=origine_x+colonne(int(c,16))*largeur_x
y_min=origine_y+ligne(int(c,16))*largeur_y
x_max=x_min+largeur_x
y_max=y_min+largeur_y

print("# image %s :" % image)
print("x_min=%.18f" % x_min)
print("x_max=%.18f" % x_max)
print("y_min=%.18f" % y_min)
print("y_max=%.18f" % y_max)

Télécharger le programme zoom.pyw

Par exemple pour l'image n°5FD76 le programme affiche les lignes suivantes, directement utilisables dans le programme mandelbrot.pyw :

# image 5FD76 :
x_min=-0.771708170565200802
x_max=-0.767852783195447697
y_min=-0.113838195815268217
y_max=-0.110946655287953388

En modifiant la valeur de la variable image dans le programme zoom.pyw (en rouge dans le code source ci-dessus) vous obtenez instantanément la valeur du zoom (valeur des 4 variables x_min, x_max, y_min et y_max) à utiliser dans le programme mandelbrot.pyw afin d'obtenir l'image correspondante.

Et pour finir voici l'image n°61FA7A en haute résolution (1280x1024 pixels) :

Voici les lignes à modifier dans le programme mandelbrot.pyw pour obtenir une telle image :

# image 61FA7A :
x_min=-0.164484659829085167
x_max=-0.163520812986646891
y_min=-0.656002044686799568
y_max=-0.655279159554970847

# résolution de l'image :
res_x=1280
res_y=1024

# nombre d'itérations fixe :
iter_max=800

# crée une figure dans la fenêtre et un axe dans la figure :
fig=plt.figure(1, figsize=(12.8, 10.24))

# affiche l'image :
ax.imshow(tab, cmap='PuBuGn', interpolation='none')

Pour visiter une galerie de plus de 100 000 images fractales, cliquez-ici.

Pour voir des vidéos représentant des zooms dans l'ensemble de Mandelbrot, cliquez-ici.

Générateur automatique d'images fractales issues de l'ensemble de Mandelbrot

Le programme gene_mandelbrot.pyw permet de générer automatiquement un ensemble d'images à partir d'une liste.

Pour programmer les images il suffit de renseigner la liste liste_images en y indiquant les numéros des images à calculer :

# liste des images à créer :
liste_images=['A36AF14','A36AF18','A36AF19']

Ce programme n'affiche pas les images à l'écran, mais il les enregistre directement dans des fichiers PNG portant le numéro de l'image (par exemple A36AF18.png pour l'image n°A36AF18), avec une résolution de 800x600 pixels (et 100 pixels par pouce) et en utilisant la palette de couleur RdBu.

Pour préparer la liste des images à calculer en Python on peut utiliser l'explorateur de l'ensemble de Mandelbrot sur Gecif.net.

Il est alors très facile de préparer une liste d'images en quelques clics et par un simple copier/coller . Exemple :

# liste des images à créer :
liste_images=['9759',
'9752',
'97550',
'97551',
'97552',
'97553',
'97554',
'97555',
'97556',
'97557',
'97558',
'97559',
'9755A',
'9755B',
'9755C',
'9755D',
'9755E',
'9755F']

Libre à vous désormais d'aller explorer l'ensemble de Mandelbrot à la recherche d'images fractales exceptionnelles et encore jamais calculées !