sierpinsky.py

Contenu du fichier

''' **********************************************************************
    Fichier sierpinsky.py

    Programme qui dessine un triangle de Sierpinsky

    auteur gabriel girard
    date 2017

    Entree : (clavier) la profondeur du fractal
    Sortie : (ecran) le triangle fractal
********************************************************************** '''
import sfml as sf


TAILLE_PAR_DEFAUT = 800
COULEUR_PAR_DEFAUT = 1

# --------------------
# Type "Point"
#
# Chaque fonction reçoit un paramètre implicite de type Point (self)
#
class Point:
    # -----------------------------------------------------------
    # Constructeur qui initialise le contenue du point avec des
    # valeurs passées en paramètres
    # Entree : (parametre) les valeurs en x et y
    def __init__(self, x=0, y=0):
        self.coordonneeX = int(x)
        self.coordonneeY = int(y)
    # -----------------------------------------------------------
    # Fontion qui permet de ré-initialiser un point
    # Entree : (parametre) les valeurs en x et y
    def init(self, x, y):
        self.coordonneeX = int(x)
        self.coordonneeY = int(y)
    # -----------------------------------------------------------
    # Fonction qui retourne le point "milieu" entre 2 points
    # Entree : (parametre) un point
    # Sortie : le point milieu entre les 2 points
    def milieu(self, y):
        pt = Point()
        pt.coordonneeX = (self.coordonneeX + y.coordonneeX)/2
        pt.coordonneeY = (self.coordonneeY + y.coordonneeY)/2
        return pt
    # ------------------------------------------------------------
    # Fontion qui initialise les coordonnées d'un point avec une
    # lecture au clavier
    # Entree (clavier) les valeurs en x et y
    def lecture(self):
        self.coordonneeX = int(input("Valeur : "))
        self.coordonneeY = int(input("Valeur : "))
    # ------------------------------------------------------------
    # Fontion qui retourne la coordonnée en x du point
    # Sortie : la valeur en x du point
    def valX(self):
        return self.coordonneeX
    # ------------------------------------------------------------
    # Fontion qui retourne la coordonnée en y du point
    # Sortie : la valeur en y du point
    def valY(self):
        return self.coordonneeY

# ----------------------------------------------------------------
# Classe Canevas pour afficher graphiquement
# (définie une fenêtre d'affichage).

class Canevas:
    # ------------------------------------------------------------
    # Initialisation  et affichage de la fenêtre
    # La fenêtre est de 800x800 avec un fond noir
    def __init__(self):
        self.canevas = sf.graphics.RenderWindow(sf.window.VideoMode(TAILLE_PAR_DEFAUT, TAILLE_PAR_DEFAUT), "Canevas de travail")
        self.tailleX = TAILLE_PAR_DEFAUT
        self.tailleY = TAILLE_PAR_DEFAUT
        self.canevas.display()
    # ------------------------------------------------------------
    # Destruction de la fenêtre d'affichage
    def __del__(self):
        print("fin......................:")
        self.canevas.close()
    # ------------------------------------------------------------
    # On efface entièrement le contenu affiché sur la fenêtre
    def effacer(self):
        self.canevas.clear(sf.graphics.Color.BLACK)
    # -----------------------------------------------------------------
    # On dessine une forme (triangle) dans la fenêtre et on l'affiche
    # Entree : la forme à dessiner
    def dessiner(self, forme):
        self.canevas.draw(forme)
        self.canevas.display()

''' ---------------------------------------------------
    Fonction dessinerTriangle

    Calcule les différents points nécessaire pour afficher
    le triangle et dessine un triangle plein sur le canevas

    Entree :
     Entree :
        (parametre) le canevas
        (parametre) les 3 points du triangle courant
    Sortie : un triangle
------------------------------------------------------'''
def dessinerTriangle(ecran, p1, p2, p3):
    triangle = sf.graphics.ConvexShape()
    # définit le nombre de points (3)
    triangle.point_count = 3
    triangle.fill_color = sf.graphics.Color.GREEN
    # définit les points
    triangle.set_point(0, sf.system.Vector2(p1.valX(), p1.valY()))
    triangle.set_point(1, sf.system.Vector2(p2.valX(), p2.valY()))
    triangle.set_point(2, sf.system.Vector2(p3.valX(), p3.valY()))
    ecran.dessiner(triangle)

''' ---------------------------------------------------
    Fonction sier

    Cette fonction dessine récursivement un "sierpinski gasket"
    Entree :
        (parametre) le canevas
        (parametre) les 3 points du triangle courant
        (parametre) le niveau de récursivité
    Sortie : Le triangle de Sierpinsky
------------------------------------------------------'''

def sier(ecran, p1, p2, p3, niveau):
    if niveau == 0:
        # dessiner un triangle plein
        dessinerTriangle(ecran, p1, p2, p3)
    else:
        # faire les trois sous-paniers de Sierpinski
        niveau -= 1
        sier(ecran, p1, p1.milieu(p2), p1.milieu(p3), niveau)
        sier(ecran, p2.milieu(p1), p2, p2.milieu(p3), niveau)
        sier(ecran, p3.milieu(p1), p3.milieu(p2), p3, niveau)

''' ---------------------------------------------------
    Porgramme principal

    Initialise et appele la fonction sier pour dessine le gasket

    Entree : (clavier) le niveau du fractal
------------------------------------------------------'''

ecran = Canevas()
#  Lecture du niveau
niv = int(input("Entrez le niveau "))
# Calculer les points de départ du triangle
p1 = Point(100, 700)
p2 = Point(700, 700)
p3 = Point(400, 100)

sier(ecran, p1, p2, p3, niv)
pause = input("Entrez un caractere pour terminer la pause : ")