Important
Pour toutes informations concernant les droits d'utilisation, veillez vous référer à la Licence
Warning
Ce projet a été développé sur la version 3.12.6 de python sur l'OS Windows 11. Veuillez vérifier les compatibilités de versions des logiciels que vous utilisez. De plus, ce projet n'est, en aucun cas, certifié infaillible, il peut donc contenir des bugs... Merci de votre compréhension.
Ce projet a été réalisé dans le cadre de l'enseignement NSI (Numérique et Sciences Informatiques) en Terminale. Il s'agit d'une interface graphique (GUI) en Python utilisant le module Turtle pour générer différentses fractales. L'utilisateur peut interagir avec l'interface pour modifier les paramètres de génération des fractales, comme le nombre de niveaux de récursivité, la taille des éléments et bien d'autres !
Le projet met en avant plusieurs concepts clés :
- Programmation récursive : utilisée pour générer les fractales.
- Programmation orientée objet : pour structurer le code en différentes classes et rendre le programme plus modulaire / compréhensible par des développeurs externe.
- Modularité : le programme est organisé de manière à pouvoir facilement ajouter d'autres types de fractales, de nouvelles fonctionnalités à l'avenir ou encore pour être utilisé en partie par d'autre developpeurs.
Le projet met à disposition 5 types de fractales différentes :
- Fractale de Sierpinski
- Fractale de Koch
- Fractale de Fibonacci
- Fractale de Vicsek
- Fractale de Pythagore
Le panel de modification des valeurs :
Ce panel, vous permet de modifier selon vos envis, un grand nombre de paramettres afin de modéliser et d'exprimer vos talents artistique avec la représentation de fractales customisé ;) Pour ce faire, nous vous mettons à disposition la possibiliser de modifier :
- La profondeur de récursivité
- La couleur du dessins (couleur fixe / aléatoire pendant la génération)
- La longueur du trait de dessin
- La couleur de l'arrière plan
- L'orientation du curseur de dessin (360°)
- L'épaisseur du trait de dessin
- Le placement du curseur sur la toile
De plus, vous avez la possibilité d'enregister, si vous le souhaitez une ou plusieurs image(s) de votre travail et de changer le curseur de dessins !
Vous souhaitez modifier le projet ? Vous souhaiter intéger de nouvelles fractales / récupérer les différentes class object, ajouter de nouveaux curseurs ou bien simplement comprendre le code source de
| Fonctions | Description |
|---|---|
| def init(self, profondeur, couleurTrait, longueurTrait, couleurBackground, turtle, screen) -> None : | Méthode d'initialisation de la class, grâce à l'intanciation de la class par l'objet1. Cette méthode, permet donc la création de cette meme class et l'instanciation de la class MainFractaleFestion Input : - prodondeur (int), - couleurTrait (str), - longeurTrait (int), - couleurBackgound (str), - turtle (TurteModule), - screen (TurtleModule) Output : None |
| def ProfondeurAffichage(self, value, textProfondeur): | Méthode modifiant l'affichage de la valeur de prodondeur sur l'interface utilisteur et sur les attributs de MainFractaleGestion. Input : - value (str), - textPrfondeur (variable tkinter) Output : None |
| def ChoixCouleur(self, cadreVisuelCouleur, bouttonChoixCouleur): | Méthode modifiant l'affiche de la valeur couleur sur l'interface utilisteur (code + bg visualisation) et sur les attributs de MainFractaleGestion. (soit unique / soit aléatoire). Ouverture d'une fenetre question (unique / aléatoire). Ouverture d'une fenetre que choix de couleur. Input : - cadreVisuelCouleur (element tkinter), - buttonChoixCouleur (element tkinter) Output : None |
| def LongueurTraitAffichage(self, value, textlongueurTrait): | Méthode modifiant l'affiche de la valeur de longeur du trait sur l'interface utilisteur et sur les attributs de MainFractaleGestion Input : - value (str), - textLongueurTrait (variable tkinter) Output : None |
| def ClearMake(self, cadreVisuelBackground): | Méthode permettant de supprimer tout ce qui se trouve sur le canvas. Avant cela le script demande une confirmation sous forme d'une fenetre avec une question. Et une possibilité de sauvegarder ou non une image du dessin. Après cela, l'interface utilisateur est mise à jour Input : - cadreVisuelBackground (element tkinter) Output : None |
| def ChoixBackground(self, cadreVisuelBackground): | Méthode permettant de choisir l'arrière plan du canvas. Ouverture d'une fenetr de choix de couleur, Mise à jour de l'interface utilisateur en fonction. Input : - cadreVisuelBackground (element tkinter) Output : None |
| def OrientationAffichage(self, value, textOrientation): | Méthode permettant de choisir l'orientation du curseur. Input : - textOrientation (element tkinter) Output : None |
| def EpaisseurAffichage(self, value, textEpaisseur): | Méthode permettant de modifier l'épaisseur du trait de dessin Input : - value (str), - textEpaisseur (element tkinter) Output : None |
| def ActiveCurseurPosition(self): | Méthode qui active simplement le get du click gauche et qui appel la méthode privé compétente Input : None Output : None |
| def LancerPauseAppel(self, typeFractale = None): | Méthode permettant de lancer ou de mettre en pause en fonction de l'état de la pause et d'agir sur la class MainFractaleGestion Input : - typeFractale : (str) None si aucune valeur envoyé Output : None |
| def SaveAsPng(self): | Méthode permettant l'enregistrement du canvas déssiné par l'utilisateur au formet png. Le script prend un screen de la fenetre canvas, le sauvgarde en PostScript et puis le convertit au format png. Il ouvre une fenetre permettant à l"utilisteur de choisir le chemin d'enregistrement de l'image. Input : None Output : image.png |
| Fonctions | Description |
|---|---|
| def init(self, turtle, screen) -> None: | Méthode d'initialisation de la class cursor, permettant de changer de curseur. Prend la forme d'une fenetre avec une sélection multiple Input : - turtle (element turtle), - screen (element turtle) Output : None |
| OpenWindow(self) | Méthode qui permet d'ouvrir la fenetre qui contient tout les boutons de sélection. Cette méthode contient également une vérification pour éviter d'ouvrir plusieur fois la même fenetre. Input : None Output : None |
| Fonctions | Description |
|---|---|
| def toggle_pause(typeFractale = None): | Fonction qui permet de mettre à jour l'affichage du bouton pause et d'appeler la méthode compétente Input : - typeFractale (str ou None si aucune valeur) Output : None |
| def LienOuvrir(lien): | Fonction pour ouvrir un lien dans un navigateur Input : None Ouput : None |
| def SeparatorAdd(): | Fonction qui ajoute un séparateur pour épurer l'affichage Input : None Ouput : None |
| Fonctions | Description |
|---|---|
| def init(self, profondeur, couleurTrait, longueurTrait, turtle, screen) -> None: | Méthode permettant d'initialiser les valeurs de la class MainFractaleGestion Input : - profondeur (int), - couleurTrait (str), - longueurTrait (int), - turtle (turtle element), - screen (turtle element) Output : None |
| def ChangerProfondeur(self, profondeur): | Méthode pour mettre à jour la profondeur de génération Input : - profondeur (int) Output : None |
| def ChangerCouleur(self, newCouleurTrait): | Méthode permettant de metrre à jour la couleur du trait de dessin Intput : - newCouleurTrait (str) Output : None |
| def ChangerlongueurTrait(self, newlongueurTrait): | Méthode pour changer la longueur du trait de dessin Input : - newlongueurTrait (int) Output : None |
| def Lancer(self, fractaleType): | Méthode pour lancer la génération de la bonne fractale et de reprendre si pas terminé Input : - fractaleType (str) Output : None |
| def Pause(self): | Méthode de mise en pause Input : None Output : None |
| Fonctions | Description |
|---|---|
| def init(self, nombre, longueur, gestionnaire): | Méthode d'initialisation de la class, grâce à l'intanciation de la class. Input : - nombre (int), - longueur (int), - gestionnaire (class parent), Output : None |
| def dessiner(self): | Méthode qui permet de reprendre ou non le dessin |
Pour ajouter une nouvelle fractale, veuillez respecter la mise en page suivante. Dans le fichier
ModuleFractales.py, ajouter une nouvelle class comme l'exemple ci-dessous.
Warning
Chaque élément turtle pour le corps de votre fractale récursive, doit obligatoirement être précédé de self.gestionnaire.turtle
class <nomFractale>:
# Méthode obligatoire (non modifiable)
def __init__(self, nombre, longueur, gestionnaire):
self.nombre = nombre
self.longueur = longueur
self.gestionnaire = gestionnaire
self.state = []
# Méthode obligatoire (modifiable)
def __Dessiner< nom >__(self, n, l):
# Élément non modifiable
if self.gestionnaire.isPaused:
self.state.append((n, l, self.gestionnaire.turtle.position(), self.gestionnaire.turtle.heading()))
return
# Élément non modifiable
self.gestionnaire.turtle.speed(10)
self.gestionnaire.screen.update()
# Élément non modifiable
if self.gestionnaire.couleurTrait == "Random":
self.gestionnaire.__CouleurRandom__()
# Partie modulable, pour dessiner en récursif la fractale
# Élément modifiable
< script récursif de votre fractale >
# Méthode obligatoire (modifiable)
def __ReprendreDessin__(self):
if self.state:
n, l, pos, heading = self.state.pop()
self.gestionnaire.turtle.penup()
self.gestionnaire.turtle.setposition(pos)
self.gestionnaire.turtle.setheading(heading)
self.gestionnaire.turtle.pendown()
self.__Dessiner< nom >__(n, l) # Modification ici
else:
self.__Dessiner< nom >__(self.nombre, self.longueur)
# Méthode obligatoire (non modifiable)
def dessiner(self):
if not self.gestionnaire.isPaused:
self.__ReprendreDessin__()Après avoir ajouté votre
classFractale, vous devez configurer l'option d'appel de votre nouvelle class. Pour ce faire, dans le fichierModuleFractales.py, dans la classMainFractaleGestion, dans la méthodeLancerrespecter la disposition suivante et ajouter votre nouvelleclassFractale
Note
Le nomFractaleSimple, sera le nom qui sera affiché dans le menu déroulant de l'interface utilisateur. Ce sera également le même texte pour l'étape suivante.
class MainFractaleGestion(object):
def __init__(self,**args):
pass
def Lancer(self, fractaleType):
match fractaleType:
case "Sierpinski":
self.fractale = FractaleSierpinski(self.profondeur, self.longueurTrait, self)
case "Koch":
self.fractale = FractaleKoch(self.profondeur, self.longueurTrait, self)
case "<nomFractaleSimple>":
self.fractale = < nomFractale >(self.profondeur, self.longueurTrait, self)
...
self.fractale.dessiner()Enfin, il faut ajouter le
nomFractaleSimple, de l'étape précédente dans la variablefractaleListedu fichiersettings.py.
fractaleListe = ("Sierpinski", "Koch","<nomFractaleSimple>")Pour ajouter des curseurs custom, vous devez suivres les étapes suivants.
Placer dans le dossier Cursor du projet, votre curseur custom sous ce format : < nom >.gif
Dans le fichier
settings.pyajouter le < nom > de votre curseur à la suite de la liste :
cursorListe = ["sun", "leaf", "unicorn", "< nom >"]Tip
Vérifiez la résolution de votre image avant de l'intégrer. De plus, si vous ne voyez pas le bouton de votre curseur apparaître, vérifiez la taille de la fenêtre de sélection (mettre en grand écran).
Pour récupérer le projet :
Dans un terminal, rentrer la commande :
git clone https://github.com/Gandalf0207/FractaloPy.gitDans le dossier du projet, dans un terminal, rentrer la commande :
python -m pip install -r Requirements.txtAprès cela, exécuter le fichier Main.py
Tip
Assurez-vous d'avoir les droits nécessaires et que Python soit correctement installé au préalable sur votre machine.
Made by Vuadelle Cyanne, Berruezo Loan, Luban Théo, Pladeau Quentin with ❤️