Projet

dessiner.py

@@ -0,0 +1,175 @@
+"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes
+ 
++ triangle_equilateral(cote, info_feutre, coordonnees)
++ arc_de_cercle(rayon, angle, info_feutre, coordonnees)
+ 
+ 
+Exemples d'utilisation :
+>>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
+>>> triangle_equilateral(50, informations_feutre, (50,100))
+>>> arc_de_cercle(75, 360, informations_feutre, (200,-200))
+"""
+ 
+ 
+# Importation
+ 
+import turtle as trt
+import random as rd
+ 
+ 
+# Déclaration des fonctions privées
+ 
+def nouveau_stylo(ecriture, fond, largeur):
+    """Renvoie la référence d'un stylo configuré
+ 
+    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
+    :: param fond(str)      :: la couleur de fond pour ce stylo
+    :: param largeur(int)   :: la largeur du trait
+    :: return (Turtle)      :: renvoie un objet de la classe Turtle
+ 
+    """
+    feutre = trt.Turtle()
+    feutre.color(ecriture)
+    feutre.fillcolor(fond)
+    feutre.pensize(largeur)
+    feutre.speed(5)
+    return feutre
+ 
+def deplacer(feutre, x, y):
+    """Lève le feutre, déplace le feutre et abaisse le feutre
+ 
+    :: param feutre(Turtle) :: la référence de l'objet Turtle
+    :: param x(int)         :: coordonnée horizontale (abscisse)
+    :: param y(int)         :: coordonnée verticale (ordonnée)
+    :: return (None)        :: c'est une fonction sans retour
+    .. effet de bord        :: modifie l'état de feutre
+ 
+    """
+    feutre.penup()       # On lève la pointe
+    feutre.goto(x, y)  # On déplace le crayon
+    feutre.pendown()     # On abaisse la pointe
+ 
+def trace_triangle_equilateral(feutre, cote):
+    """Trace un triangle (equilatéral) à l'aide du crayon feutre
+ 
+    :: param feutre(Turtle) :: la référence de l'objet Turtle
+    :: param cote(int)      :: la valeur en pixel des côtés 
+    :: return (None)        :: fonction sans retour
+    .. effet de bord        :: modifie l'état de feutre
+ 
+    """
+    feutre.begin_fill()
+    for x in range(3):
+        feutre.forward(cote)
+        feutre.left(120)
+    feutre.end_fill()
+    feutre.hideturtle()
+ 
+def trace_arc(feutre, rayon, angle):
+    """Trace un arc de cercle à l'aide du crayon feutre
+ 
+    :: param feutre(Turtle) :: la référence de l'objet Turtle
+    :: param rayon(int)     :: la valeur en pixel du rayon
+    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
+    :: return (None)        :: fonction sans retour
+    .. effet de bord        :: modifie l'état de feutre
+ 
+    """
+    feutre.begin_fill()
+    feutre.circle(rayon, angle)
+    feutre.end_fill()
+    feutre.hideturtle()
+    
+def trace_rectangle(feutre, largeur, longueur):
+    """Trace un rectangle à l'aide du crayon feutre
+        
+    :: param feutre(Turtle) :: la référence de l'objet Turtle
+    :: param longueur(int)  :: la valeur en pixel des cotés sur la longueur
+    :: param largeur(int)   :: la valeur en pixel des cotés sur la largeur
+    :: return (None)        :: fonction sans retour
+    """
+    feutre.begin_fill()
+    feutre.right(180)
+    feutre.forward(longueur)
+    feutre.right(90)
+    feutre.forward(largeur)
+    feutre.right(90)
+    feutre.forward(longueur)
+    feutre.right(90)
+    feutre.forward(largeur)
+    feutre.end_fill()
+    feutre.hideturtle()
+ 
+ 
+# Déclarations des fonctions publiques
+ 
+def triangle_equilateral(cote, info_feutre, coordonnees):
+    """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées
+ 
+    :: param cote(int)                     :: la valeur en pixel des côtés
+    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+ 
+    """
+    ecriture = info_feutre['écriture']
+    fond = info_feutre['fond']
+    epaisseur = info_feutre['épaisseur']
+    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
+    y = coordonnees[1]
+ 
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    deplacer(feutre, x, y)
+    trace_triangle_equilateral(feutre, cote)
+ 
+    return feutre
+ 
+def arc_de_cercle(rayon, angle, info_feutre, coordonnees):
+    """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées
+ 
+    :: param rayon(int)                    :: la valeur en pixel du rayon
+    :: param angle(int)                    :: la valeur en ° de l'angle
+    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+ 
+    """
+    ecriture = info_feutre['écriture']
+    fond = info_feutre['fond']
+    epaisseur = info_feutre['épaisseur']
+    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
+    y = coordonnees[1]
+ 
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    deplacer(feutre, x, y)
+    trace_arc(feutre, rayon, angle)
+ 
+    return feutre
+
+def rectangle(largeur, longueur, info_feutre, coordonnees):
+    """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées
+ 
+    :: param largeur(int)                  :: la valeur en pixel des cotés de a largeur
+    :: param longueur(int)                 :: la valeur en pixel des cotés de la longueur
+    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+ 
+    """
+    ecriture = info_feutre['écriture']
+    fond = info_feutre['fond']
+    epaisseur = info_feutre['épaisseur']
+    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
+    y = coordonnees[1]
+ 
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    deplacer(feutre, x, y)
+    trace_rectangle(feutre, largeur, longueur)
+ 
+    return feutre
+ 
+# Instructions du programme principal
+ 
+if __name__ == '__main__':
+ 
+    informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5}
+    triangle_equilateral(50, informations_feutre, (50,100))
+    arc_de_cercle(75, 360, informations_feutre, (200,-200))
+    rectangle(140, 80, informations_feutre, (300, -200))

rue.py

@@ -0,0 +1,90 @@
+"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
+ 
++ dessiner_rue_aleatoire()
++ dessiner_rue_decrite(rue:dict)
+"""
+ 
+ 
+# Importation
+ 
+import dessiner as ds
+import turtle as trt
+import random as rd
+ 
+ 
+# Constantes
+ 
+LARGEUR_IMMEUBLE = 140
+ 
+ 
+# Fonction privées
+ 
+def immeuble_aleatoire(numero:int) -> dict:
+    informations = {}
+    informations['couleur_facade'] = couleur_aleatoire()
+    informations['numero'] = numero
+    informations['etages'] = rd.randint(2,6)
+    return informations
+ 
+def couleur_aleatoire() -> str:
+    liste = ["red","blue","yellow","black","orange","purple","brown","pink","green"]
+    couleur = rd.randint(0,len(liste)-1)
+    return liste[couleur]
+    
+def coordonnees_facade(immeuble:dict) -> tuple:
+    x_gauche = -200 + 200 * immeuble['numero']
+    y_bas = -100
+    return (x_gauche, y_bas)
+
+def coordonees_fenetre(immeuble:dict) -> tuple:
+    x_gauche, y_bas = coordonnees_facade(immeuble)
+    x_gauche = x_gauche - 100
+    y_bas = y_bas + 20
+    return (x_gauche, y_bas)
+     
+def dessiner_facade(immeuble:dict) -> None:
+    # Traduction des données de rue vers dessiner
+    crayon = {}
+    crayon['écriture'] = "grey"
+    crayon['fond'] = immeuble['couleur_facade']
+    crayon['épaisseur'] = 3
+    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
+    cote = LARGEUR_IMMEUBLE
+    # Demande d'affichage
+    for i in range(immeuble['etages']):
+        ds.rectangle(80, cote, crayon, (x,y + i * 80))
+ 
+def dessiner_porte(immeuble:dict) -> None:
+    # Traduction des données de rue vers dessiner
+    crayon = {}
+    pass
+
+def dessiner_fenetre(immeuble:dict) -> None:
+    crayon = {}
+    crayon['écriture'] = 'white'
+    crayon['fond'] = 'blue'
+    crayon['épaisseur'] = 2
+    x, y = coordonees_fenetre(immeuble)
+    cote = 30
+    ds.rectangle(cote, cote, crayon, (x,y)) 
+    
+ 
+def dessiner_immeuble(immeuble:dict) -> None:
+    dessiner_facade(immeuble)
+    dessiner_porte(immeuble)
+    dessiner_fenetre(immeuble)
+    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
+ 
+def dessiner_rue_aleatoire() -> None:
+    for n in range(4):
+        informations_immeuble = immeuble_aleatoire(n)
+        dessiner_immeuble(informations_immeuble)
+ 
+def dessiner_rue_decrite(rue:'?') -> None:
+    pass
+ 
+ 
+# Programme principal
+ 
+if __name__ == '__main__':
+    dessiner_rue_aleatoire()