Aller au contenu

TP - Création d'immeubles

Dans le dossier [NSI], créez le dossier [F02-Module Turtle].

Téléchargez le fichier « à trous » TPF02.11.py (clic droit -> Enregistrer sous]) et enregistrez-le dans ce dossier.

Important

Dans chaque fonction à programmer, remplacez le mot-clef pass par les instructions nécessaires.

Source

L'idée originale de ce TP est celle d'un collègue dont je n'ai pas le nom. Qu'il n'hésite pas à se manifester afin que je puisse le créditer ici ;-).

Travail à réaliser

Immeubles

Écrire (compléter) un programme qui permet de générer « aléatoirement » le dessin d’une rue d'immeuble à l'aide du module turtle de Python en respectant le cahier des charges suivant :

  • les immeubles ont au minimum un rez-de-chaussée et au maximum 4 étages (5 niveaux) ;
  • les immeubles ont une largeur de 140 pixels ;
  • les immeubles ont une couleur unique pour toute la façade ;
  • chaque niveau (rez-de-chaussée ou étage) a une hauteur de 60 pixels ;
  • les rez-de-chaussée n'ont qu'une seule porte ;
  • toutes les fenêtres sont identiques, de taille 30 pixels sur 30 pixels ;
  • toutes les portes et portes-fenêtres ont une largeur de 30 pixels.

Tout le reste est libre et pourra donc être « personnalisé » si vous finissez le TP avant la fin.

Partie 1 - Préparation des fonctions génériques

  1. Complétez le corps de la fonction couleur_aleatoire() en respectant ses spécifications.

    1
    2
    3
    4
    def couleur_aleatoire():
        """
        Sortie: tuple - triplets RGB d'entiers aléatoires compris entre 0 et 255
        """
    

    Exemple de test
    >>> couleur_aleatoire()
    (118, 12, 203)
    
  2. Complétez le corps de la fonction aller_sans_tracer() en respectant ses spécifications.

    1
    2
    3
    4
    5
    6
    def aller_sans_tracer(stylo, x, y):
        """
        stylo - une tortue
        x, y - deux entiers
        Sortie: None - La tortue se rend aux coordonnées (x, y) sans tracer
        """
    

  3. Complétez le corps de la fonction rectangle() en respectant ses spécifications.

    1
    2
    3
    4
    5
    6
    7
    8
    def rectangle(stylo, x, y, w, h):
        """ linenums='1'
        stylo - une tortue
        x, y - deux entiers, coordonnées du coin "bas/gauche" du rectangle
        w - entier positif, largeur du rectangle
        h - entier positif, hauteur du rectangle
        Sortie: None - La tortue trace le rectangle
        """
    

  4. Vérifiez votre travail en copiant/collant les lignes suivantes dans le programme principal, à la place du commentaire # A compléter ici :

    175
    176
    177
    178
        for i in range(1, 5):
            x = randint(-300, 100)
            y = randint(-300, 100)
            rectangle(sophie, x, y, 50*i, 60*i)
    
    Immeubles

Partie 2 - Construction des différents éléments

  1. Une fenêtre est un carré de 30 pixels sur 30 pixels, de couleur fixée (légérement grise).
    Complétez le corps de la fonction fenetre() en faisant appel à la fonction rectangle.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def fenetre(stylo, x, y):
        """
        stylo - une tortue
        x - entier, l'abcisse du côté gauche de la fenêtre
        y - entier, l'ordonnée du sol du niveau de la fenetre
        Sortie: None - Tracé de la fenêtre
        """
        stylo.pensize(1)
        stylo.fillcolor('#ddd')
    

    Exemple de test

    Le code

    >>> fenetre(sophie, 0, 0)
    
    exécute le dessin :

  2. Le premier style de porte est un rectangle de 30 pixels sur 50 pixels, de couleur paramétrable.
    Complétez le corps de la fonction porte1().

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def porte1(stylo, x, y, couleur):
        """
        stylo - une tortue
        x - entier, l'abcisse du côté gauche de la porte
        y - entier, l'ordonnée du sol du niveau de la porte
        couleur - triplet d'entiers, couleur (r, g, b) de la porte
        Sortie: None - Tracé d'un premier style de porte
        """
        stylo.pensize(1)
    

    Exemple de test

    Le code

    >>> porte1(sophie, 0, 0, (255, 0, 0))
    
    trace une porte rouge :

  3. Le second style de porte est un rectangle de 30 pixels sur 40 pixels, de couleur paramétrable et surmontée d'un demi-disque.
    Complétez le corps de la fonction porte2().

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def porte2(stylo, x, y, couleur):
        """
        stylo - une tortue
        x - entier, l'abcisse du côté gauche de la porte
        y - entier, l'ordonnée du sol du niveau de la porte
        couleur - triplet d'entiers, couleur (r, g, b) de la porte
        Sortie: None - Tracé d'un second style de porte
        """
        stylo.pensize(1)
    

    Exemple de test

    Le code

    >>> porte1(sophie, 0, 0, (0, 0, 255))
    
    trace une porte bleue surmontée d'une demi-disque :

  4. Les portes-fenêtres sont des rectangles gris de 30 pixels sur 50 pixels. On trace ensuite la barrière de dimensions 40 pixels sur 25 pixels et constituée de dix barreaux verticaux d'épaisseur 3.
    Complétez le corps de la fonction fenetre_balcon().

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def fenetre_balcon(stylo, x, y):
        """
        stylo - une tortue
        x - entier, l'abcisse du côté gauche de la -fenetre-balcon
        y - entier, l'ordonnée du sol du niveau de la porte-fenetre-balcon
        Sortie: None - Tracé d'une porte-fenêtre puis du balcon "par-dessus"
        """
        stylo.pensize(1)
        stylo.fillcolor('#ddd')
    

    Exemple de test

    Le code

    >>> fenetre_balcon(sophie, 0, 0)
    
    trace une porte-fenêtre :

  5. Le premier type de toit est un triangle isocèle noir de largeur 160 pixels et de hauteur 40 pixels. Complétez le corps de la fonction toit1().

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    def toit1(stylo, x, y_sol, niveau):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        couleur -triplet d'entiers, couleur (r, g, b) de la façade
        niveau -int, nombre de niveaux (de 0 à 4 - 0 pour les rdc, ...)
        Sortie: None - La tortue trace le toit triangulaire
        """
        stylo.pensize(0)
    

    Exemple de test

    Le code

    >>> toit1(sophie, 0, 0, 3)
    
    trace un toit triangulaire 3 niveaux au-dessus du sol :

  6. Le second type de toit est un trait horizontal d'épaisseur 10 pixels et de longueur 150 pixels. Complétez le corps de la fonction toit2().

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def toit2(stylo, x, y_sol, niveau):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        couleur -triplet d'entiers, couleur (r, g, b) de la façade
        niveau -int, nombre de niveaux (de 0 à 4 - 0 pour les rdc, ...)
        Sortie: None - La tortue trace le toit plat
        """
    

    Exemple de test

    Le code

    >>> toit2(sophie, 0, 0, 2)
    
    trace un toit horizontal 2 niveaux au-dessus du sol :

  7. Vérifiez votre travail en copiant/collant les lignes suivantes dans le programme principal, à la place des essais de la partie précédente :

    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
        fenetre(sophie, -350, y_sol)
    
        aller_sans_tracer(sophie, -300, y_sol)
        couleur_porte1 = couleur_aleatoire()
        porte1(sophie, -300, y_sol, couleur_porte1)
    
        aller_sans_tracer(sophie, -250, y_sol)
        couleur_porte2 = couleur_aleatoire()
        porte2(sophie, -250, y_sol, couleur_porte2)
    
        aller_sans_tracer(sophie, -200, y_sol)
        fenetre_balcon(sophie, -200, y_sol)
    
        aller_sans_tracer(sophie, -150, y_sol)
        toit1(sophie, -150, y_sol, 2)
    
        aller_sans_tracer(sophie, 50, y_sol)
        toit2(sophie, 50, y_sol, 1)
    
    Immeubles

Partie 3 - Assemblage des différents éléments

  1. Le rez-de chaussée doit comporter une et une seul porte et deux fenêtres. De plus, cette porte n'est pas forcément à gauche sur la façade de l'immeuble. En utilisant à bon escient des valeurs aléatoires, complétez la définition de la fonction rdc() :

    1
    2
    3
    4
    5
    6
    7
    8
    def rdc(stylo, x, y_sol, c_porte):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        c_porte : couleur de la porte
        Sortie: None - La tortue trace les éléments du rez-de-chaussée
        """
    

    Un exemple de test

    Dans le programme principal, le code :

    195
    196
        couleur_porte = couleur_aleatoire()
        rdc(sophie, -300, y_sol, couleur_porte)
    
    peut donner : Immeubles

  2. Un étage comporte des fenêtres et/ou des porte-fenêtres. La probabilité de construction d'une fenêtre est deux fois plus grande que celle d'une porte-fenêtre. De plus, celles-ci doivent être tracées à la bonne « hauteur » selon le numéro de l'étage.
    En utilisant à bon escient des valeurs aléatoires, complétez la définition de la fonction etage() :

    1
    2
    3
    4
    5
    6
    7
    8
    def etage(stylo, x, y_sol, niveau):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        niveau - int, numéro de l'étage en partant de 0 pour le rdc
        Sortie: None - La tortue trace les éléments de l'étage
        """
    

    Un exemple de test

    Dans le programme principal, le code :

    196
    197
    198
        etage(sophie, -300, y_sol, 1)
        etage(sophie, -300, y_sol, 2)
        etage(sophie, -100, y_sol, 4)
    
    peut donner : Immeubles

  3. La fonction toit() construit un toit au niveau (à l'étage) proposé, de manière équiprobable entre les deux toits possibles.

    1
    2
    3
    4
    5
    6
    7
    8
    def toit(stylo, x, y_sol, niveau):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        niveau - int, numéro de l'étage en partant de 0 pour le rdc
        Sortie: None - La tortue trace le toit
        """
    

    Un exemple de test

    Dans le programme principal, le code :

    200
    201
        toit(sophie, -300, y_sol, 1)
        toit(sophie, -100, y_sol, 4)
    
    peut donner : Immeubles

  4. Pour construire l'immeuble, on commence par définir aléatoirement son nombre d'étages (de 0 à 4), puis on trace sa façade dans une couleur définie aléatoirement. Ensuite, on place le rez-de-chaussée, les étages et enfin le toit.

    1
    2
    3
    4
    5
    6
    7
    def immeuble(stylo, x, y_sol):
        """
        stylo - une tortue
        x - int, abcisse du côté gauche de la façade
        y_sol - int, ordonnée du sol du la rue
        Sortie: None - Tracé de l'immeuble
        """
    

    Un exemple de test

    Dans le programme principal, le code :

    204
        immeuble(sophie, -300, y_sol)
    
    peut donner : Immeubles

  5. En conclusion, il reste à tracer un grand trait horizontal sur le sol, puis à disposer des immeubles les uns à côté des autres pour se sentir architecte.