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 "les bases du Python" nous allons aller un peu plus loin en reprenant une activité "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.

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.

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 (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.

É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.
ATTENTION, il existe différentes façons d'exprimer une solution.
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

# 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

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.

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.

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

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().

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.

Il ne contient que des simples fonctions mathématiques. 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).

# 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))

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 disponible ici. La référence complète traduite partiellement 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.

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()

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.

t.left(360 - t.heading())
t.goto(0, -rayon)
t.circle(rayon)

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

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()