\huge \textbf{Projet}\normalsize

\

\Large \textbf{Architecture}\normalsize

Introduction

Aujourd'hui, on dessine. Mais pas n'importe comment.

Au minimim :

\ \

Et si vous êtes ambitieux :

\ \

Et vous voulez un peu plus de verdure par exemple :

\ \

\newpage

Idée générale

Voici l'idée général du projet :

On aura d'abord un premier programme formes.py comportant des fonctions capables de dessiner des formes simples. Elles utiliseront le module Turtle à l'interne.

Le résultat possible en image :

exemple_formes \ \

Un deuxième programme nommé ville.py devra être capable de dessiner une ville comportant plusieurs immeubles. Aucune ligne utilisant le module Turtle à l'intérieur de ce programme, juste des appels aux fonctions du premier programme, formes.py.

Le résultat en image :

exemple_rue \ \

Votre troisième programme interpreteur devra lire un fichier texte contenant une description codifiée de la ville et devra la tracer en utilisant... le programme 2, ville.py.

Imaginons qu'on ai un fichier exemple1.txt texte qui contienne ceci :

ville
4 immeubles
facade rouge - 2 étages - porte rouge au milieu - toit classique
facade verte - 4 étages - porte verte à droite - toit plat
aléatoire
facade violet - 3 étages - porte bleue au milieu - toit bizarre

On pourrait alors imaginer cette fonction présente dans interpreteur.py :

>>> interpreter_dessin('exemple1.txt')

exemple_interpreteur_1 \ \

\newpage

Mais on peut aussi imaginer qu'on accepte des descriptions de ce type :

ville
4 immeubles
aléatoire

Attention, le choix de la syntaxe est to1erement libre. C'est une occasion unique de créer votre langage.

Mais d'ailleurs... comment dessine Turtle ? A qui fait-il appel ?

Cahier des charges

Pour être certain de partir tous dans la même direction au début, et gagner un peu de temps de coordination, voici quelques choix imposés.

On devra pouvoir créer la ville de façon aléatoire. Elle devra alors comporter au minimum 4 immeubles différents.

exemple_rue \ \

Chaque immeuble aura les caractéristiques suivantes :

Des immeubles d'une largeur de 140 pixels,
Chaque étage fait 80 pixels,
Entre 1 à 5 étages pour un immeuble
Chaque fenêtre fait 30 px sur 30 px
Une porte unique au rez-de-chaussée de 30 px sur 50px
Deux variations du toit
Plusieurs couleurs disponibles
Il est possible que certaines fenêtres soient des portes-fenêtres de 30 px sur 50 px.

Pour simplifier les explications, je considère que votre projet comporte ces 4 fichiers, placés simplement dans le même répertoire. Bien entendu, vous êtes libres de créer un vrai package.

 projet_architecture

  -> formes.py

  -> ville.py

  -> interpreteur.py

  -> ma_ville.txt

Le projet que vous rendrez devra donc comporter au moins 4 fichiers.

Les fichiers fournis

Le premier fichier est le squelette de formes.py, le programme 1 : celui qui devra contenir des fonctions permettant de dessiner des formes géométriques basiques : carré, rectangle, disque, cercle, triangle, arc de cerle, etc.
Le squelette de ville.py, le programme qui devra contenir les fonctions permettant de dessiner des immeubles. Attention, beaucoup de choses à rajouter dans celui-ci. Pour l'instant, il trace notamment les 4 immeubles au même endroit et les immeubles ne ressemblent pas trop à des immeubles.

L'intérêt du dictionnaire est évident ici : on pourra envoyer autant de caractéristiques qu'on veut. Au début il n'y aura que le numéro dans la ville, le nombre d'étages et la couleur de la façade par exemple. On pourra y ajouter la hauteur, le type de toit, etc.

Organisation du travail

Voici une proposition d'organisation pour le début du projet mais attention, le déroulé n'est pas vraiment linéaire : à vous de vous repartir le travail :

\ \

Etape 1

S'approprier formes.py (programme incomplet pour le moment) :

Parvenir individuellement à tracer les triangles et les cercles où vous voulez.
Réfléchir ensemble aux formes générales qui vont être utiles pour faire des dessins quelconques : observer les exemples pour vous aider.
Définir ensemble les prototypes de ces fonctions : noms, paramètres nécessaires ...
L'un d'entre vous peut alors être chargé d'implémenter réellement ces fonctions pendant que le second passe à l'étape 2.

Etape 2

S'approprier ville.py (programme non fonctionnel pour le moment)

Comprendre où se détermine les caractéristiques de l'immeuble.
Comprendre pourquoi le programme affiche juste des triangles pour le moment.
Réfléchir ensemble aux caractéristiques essentielles à connaître sur un immeuble pour parvenir à le dessiner à l'écran.
L'un d'entre vous peut alors modifier la création des caractéristiques pour qu'elles soient aléatoires en partie.
L'un d'entre vous peut modifier le programme pour que les coordonnées de l'immeuble soient dépendantes du numéro de l'immeuble.
L'un d'entre vous peut utiliser les fonctions de dessin pour commencer à tracer une vraie façade et pas juste un triangle.
...

Etape 3

Réaliser entièrement le programme interpreteur.py qui doit lire un fichier texte (en suivant une syntaxe qu'il vous faudra inventer au préalable) pour parvenir à retrouver les caractéristiques voulues pour la ville (nombre d'immeubles, caractéristiques de chaque immeuble, ...). Il ne restera ensuite qu'à faire appel aux fonctions du module ville.py pour tracer votre ville.

\ \

Comment avancer ensuite ?

Déjà en réalisant rapidement un prototype d'immeuble : cela permettra de valider la communication entre les modules ville et formes.

Une fois le prototype réalisé, il suffira de rajouter les options à travers de nouvelles fonctions :

une fonction pour tracer une porte ?
une fonction pour tracer une fenêtre ?
une fonction pour tracer les fenêtres ?
une fonction pour tracer le toit ?
une fonction pour tracer une antenne ou un pigeon ?
...

Vous êtes plusieurs, il faudra vous répartir les fonctions à réaliser car ce projet nécessite beaucoup de temps.

Pour vous coordonner, il est évident qu'il faut par contre vraiment avoir défini les noms et les paramètres des fonctions avant de vraiment les réaliser.

Notation

La notation tiendra compte des éléments suivants :

La documentation des fonctions doit être bien rédigée.
Bonne pratiques de programmation : usage de noms de fonctions et variables explicites, fonctions simples quitte à les décomposer en plusieurs petites fonctions.
Les fichiers proposés sont opérationnels. Cela ne signifie pas que le projet est abouti, mais que vos fonctions ne comportent pas de bugs.
Respect du cahier des charges.
Avancement dans le projet.
Investissement lors des séances en classe ainsi qu'en dehors.

\

\underline{{\textit{\textbf{Sources}}}}

Hervé OWSINSKI, INFOFORALL / Projet Rue [en ligne], page crée en juin 2022, mise à jour en septembre 2022 [Consultée le 5 septembre 2019]. INFOFORALL : www.infoforall.fr/act/python/projet-dessine-ta-rue/