WikiTechno.morceau.fr (amen.fr)

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
======Dessin de polygones réguliers [TP 3ème]======
Cette activité est un bilan de plusieurs connaissances et compétences de cycle 4 et une ouverture à la programmation Python qui sera utilisée au lycée.

Après avoir découvert [[cours:progra10|"les bases du Python"]] nous allons aller un peu plus loin en reprenant une activité [[cours:progra6|"Dessin de polygones réguliers"]] vue lors de la découverte de la programmation en 5ème mais en réfléchissant à un algorithme plus évolué et programmant aussi en Python.

=====Problème à résoudre=====
Nous voulons dessiner des polygones réguliers ayant un nombre de cotés x choisi par l'utilisateur de même que la longueur du coté. Les angles comme les cotés des polygones sont égaux et celui ci s'inscrit dans un cercle. Le cercle sera au centre de la zone de dessin, coordonnées (0,0). Pour la version Python, le cercle englobant sera dessiné en plus.
{{ :cours:polygones2.jpg?600 |}}

=====1- Recherche de l'algorithme=====
====Éléments de solution====
Nous savons que la somme des angles d'une figure fermée correspond à celle d'un cercle 360°. Pour la dessiner, il suffit donc de calculer l'angle correspondant (angle = 360 / coté) puis de répéter autant de fois que qu’il y a de coté la séquence : avancer de distance, tourner de angle. \\
Il faut bien sur demander le nombre de coté voulu et leur longueur avant de vérifier si les réponses données sont cohérentes.

**Le 1er problème** est de centrer la figure dans l’écran en utilisant des formules mathématiques ([[wpfr>Cercle|Cercle sur Wikipédia]]). \\ 
On remarque, sur les dessins ci dessus, que les cotés des figures correspondent aux cordes d'un cercle et qu'au moins un coté est horizontal. On détermine donc le point de départ du tracé (dans un repère, l’écran, l'abscisse est fonction de la corde et l'ordonnée du cosinus de l'angle par rapport à l'axe des ordonnées).

**Le 2ème problème** consiste à déterminer la taille maximum du coté d'une figure. En effet, la taille de l'écran est fixe donc la longueur des cotés/codes des figures va devoir diminuer si le nombre de coté augmente. On trouve facilement le rayon du plus grand cercle tenant entier dans l'écran et de l'angle de chaque corde à dessiner est connu, il ne reste plus qu'a calculer la corde maximum autorisée. \\
Une fois que la longueur du coté/corde choisi par l'utilisateur est validé, on peu calculer le rayon réel de la figure et commencer le tracé.

**Pour information** : 
  * la demi hauteur de l'écran est 160 pixels pour Scratch et Codabloc, elle est de 240 pixels pour Python.
  * Scratch et Codabloc ne possèdent pas de fonction pour dessiner des cercles, d'où l'absence de dessin du cercle inclus. 

====Écriture de l'algorithme====
Écrivez VOTRE algorithme en utilisant correctement les indentations. N'importe qui l'utilisant peut arriver à tracer des polygones. 

Vous pouvez, lorsque vous avez terminé, le comparer à la solution type ci jointe. \\
<wrap em>ATTENTION, il existe différentes façons d'exprimer une solution.</wrap> \\
La solution type, qui fonctionne, doit être parfaitement comprise avant d'être comparée à la votre. Les différences doive être analysées pour voir si le même résultat final sera atteint ou s'il s'agit d'une erreur de conception.

Les commentaires (lignes débutants par # vous aident à comprendre l'algorithme mais ne seront pas à traduire.
++++Solution type|
<code>
# Initialisation
Définir le rayon maximal (rmax)
Demander et noter le nombre de coté (3 < cote <= infini)
Si cote incorrect
	Signaler l'erreur
sinon
	Calculer l'angle (angle = 360 / cote)
	Calculer la corde maxi (corde_max = 2 * rmax * sin(angle / 2)
	Demander et noter la corde (10 < corde < corde_max)
	Si corde incorrect 
		Signaler l'erreur
	sinon
		Calculer le rayon de la corde choisie (rayon = corde / 2 / sin(angle / 2))
		Calculer le point x (x = - corde / 2)
		Calculer le point y (y = rayon * cos(angle /2)
# Tracé du polygone 
		Se placer au point (x, y)
                Poser le stylo sur la fenêtre
		Répéter tant que cote > 0
			Avancer de corde
			Tourner vers la droite de angle
			Diminuer cote de 1 (cote = cote – 1)
# Tracé du cercle, uniquement en Python
		Relever le stylo
                Se positionner pour tracer le cercle englobant
		Changer de couleur de stylo
		Poser le stylo 
                Tracer le cercle
</code>
++++

=====2- Traduction en Scratch ou Codabloc=====
====Prérequis====
{{ :cours:scratch_fct_maths.jpg?100|}}
L'algorithme regroupe les blocs " Demander ... " et " Mettre variable à réponse " sur une seule ligne (méthode Python).

Parmi les opérateurs Scratch et Codabloc, le dernier de la liste donne accès aux fonctions mathématiques. En bloc, l'unité des angles est le degré d'angle.

Pour réaliser des dessins, le module Stylo est inclus dans Codabloc. (Pour l'inclure dans Scratch, il suffit de cliquer sur l'icône " Ajouter des extensions " en bas de la barre des catégories de blocs, puis de rechercher et ajouter le module Stylo.)
Par défaut, le stylo est en position relevée. Le poser pour dessiner.

Scratch possède un rayon maximum de 160 pixels pour calcul de la corde maximum.

====Utilisation du module stylo====
Le stylo doit être relevé pour se déplacer sans écrire, posé sinon. Le couleur et la taille du trait peut être modifiée.

Aller vers la droite correspond à s'orienter à 90° et avancer (0° pour aller vers le haut).

Le stylo n'est pas capable de tracer des figures géométrique, cercle compris, à l'aide d'un seul bloc. C'est pour cela que la dernière partie de l'algorithme n'est pas traité en Scratch. 

====Traduction du programme====
Traduisez votre algorithme et testez le. Si le programme fonctionne vous avez réussi. Sinon, vous pouvez essayer de trouver votre erreur en regardant la solution type ci dessous.

++++Solution type|
{{ :cours:scratch_polygonnes.jpg?800 |}}
++++

=====3- Traduction en Python=====
Le module Turtle que nous allons utiliser est une **initiation à la programmation objet**. En effet, le module correspond à une **classe** d'objets Tortues. Nous pouvons en créer plusieurs en les **instanciant** avec des noms différents, ils auront leurs propres **propriétés** (couleur, épaisseur de trait, position ...) mais utilisant les mêmes **opérations** (avancer, poser le stylo, tourner ...). Il suffit d'utiliser la notation __nom_instance.propriété__ ou __nom_instance.opération()__.

====Connaissances à acquérir====
Nous avons acquis les connaissances de bases (créer et utiliser des variables, entrer et sortir des informations, boucle " while " et condition " if - else ") dans l'activité précédente. 

Les langages de programmation sont tellement riches en possibilité qu'il n'est pas possible, pour des raison de place, de mettre toutes leurs possibilités disponibles en permanence. Nous venons de le voir en SCRATCH avec le module " Stylo " qu'il faut ajouter (en CODABLOC, il est ajouté d'office car plus fréquemment utilisé).

En Python, un module optionnel s'ajoute grâce à l'instruction " import ". Les fonctions mathématiques (autres que les opérations de base) doivent être importées. Il existe aussi un module " turtle (tortue) " similaire au stylo de scratch. Les instructions contenue dans les modules sont utilisées en plaçant devant leur nom celui du module suivit d'un point. 
===Le module math===
Il ne contient que des simples fonctions mathématiques. [[https://docs.python.org/fr/3.13/library/math.html|La référence du module est ici]] mais n'est traduite que partiellement.

Les angles doivent être en radian. Pour convertir des degrés en radian utiliser la fonction : math.radians(angle_degrés).
<code>
# Calculer le rayon d'un cercle dont on connaît la corde et l'angle en degrés 
import math
rayon = corde / 2 / math.sin(math.radians(angle/2))
</code>

===Le module turtle===
Python, contrairement à Scratch est un langage objet. En effet, en Python, nous pouvons réaliser 2 dessins indépendants en même temps. Cela se passe comme si nous avions 2 **objets** (tortues) indépendantes qui possèdent des **propriétés** propres (position, couleur, épaisseurs …) et des **opérations**/fonctions communes (avancer, tourner …) l'ensemble étant défini dans un seul module. 

Pour pouvoir utiliser notre objet, il est nécessaire de l'instancier en lui donnant un nom. C'est comme initialiser une variable à partir d'une fonction. Exemple : ma_tortue = turtle.Turtle(). La fonction d'instanciation reprend le nom du module avec une majuscule et parfois des paramètres initiaux.

Une explication, en français, est [[https://fr.python-3.com/?p=324|disponible ici]]. La référence complète traduite partiellement [[https://docs.python.org/fr/3/library/turtle.html|est ici]].

Certaines fonctions possèdent plusieurs noms (nom raccourcis). 
  * Liste à pucePour déplacer la tortue : forward(dist), backward(dist), right(angle), left(angle), goto(posx, posy)
  * Liste à pucePour modifier le stylo : pendown(), penup(), color(" couleur "), pensize(taille). 
  * pour montrer/cacher la tortue : showturtle(), hideturtle()
  * Sur Capytale, pour que le dessin soit visible, il faut terminer par turtle.done().
  * Par défaut, le stylo est en position d'écriture. Le relever pour se positionner sans tracer.
<code>
import turtle
t1 = turtle.Turtle()
t2 = turtle.Turtle()
t1.color("red")
t1.forward(100)
t2.color("blue")
t2.pensize(3)
t2.right(90)
t2.forward(100)
turtle.done()
</code>

Le module turtle possède une fonction " circle(rayon) " permettant de tracer un cercle de rayon donné en tournant à gauche à partir de la position de la tortue. Dans la pratique, si l'on connaît le centre, se tourner vers la droite et se positionner de la valeur du rayon en dessous de ce dernier.
<code>
t.left(360 - t.heading())
t.goto(0, -rayon)
t.circle(rayon)
</code>

====Traduction de l'algorithme====
Vous en connaissez maintenant suffisamment pour traduire l'algorithme, en entier cette fois. S'il fonctionne, même après quelques retouches, de syntaxe : BRAVO. Sinon vous pouvez vous aider de la solution type ci dessous.

++++Solution type|
<code python>
import turtle
import math
t = turtle.Turtle()
bord = 480
# Initialisation
cote = int(input("Nombre de coté (3 et plus) ? "))
if cote < 3 :
    print ("Il faut plus de 3 cotés !")
else :
    angle = 360/cote
    cmax = int(bord * math.sin(math.radians(angle/2)))
    corde = int(input(f"Longueur du coté (10 à {cmax}) ? "))
    if (corde < 10) or (corde > cmax) :
        print ("Longueur incorecte !")
    else :
        r = corde / 2 / math.sin(math.radians(angle/2))
        x = corde / 2
        y = r * math.cos(math.radians(angle/2))
        # Tracé figure
        t.penup()
        t.goto(- x, y)
        t.pendown()
        while cote > 0:
            t.forward(corde)
            t.right(angle)
            cote = cote – 1
        # Tracé cercle englobant
        t.penup()
        t.goto(0, -r)
        t.color("blue")
        t.pendown()
        t.circle(r)
turtle.done()
</code>
++++
WikiTechno.morceau.fr (amen.fr)

Outils pour utilisateurs

Outils du site

Outils de la page
