Mathématice, intégration des Tice dans l'enseignement des mathématiques  
Sommaire > N°61 - Septembre 2018 > Changement de repère et effets perceptifs

Changement de repère et effets perceptifs
Moteur de recherche
Mis en ligne le 8 juin 2018, par Aymeric Picaud

L’origine de ce document était d’illustrer l’effet de la fonction setworldcoordinates dans une fenêtre créée avec le module turtle de Python. L’utilisation de Python pour représenter des fonctions a été abordée par François Goichot dans son article (Python et les graphes de fonctions). Une analyse du changement de repère dans le module turtle de Python est suivie d’une comparaison des changements de repères dans d’autres logiciels. Le critère de comparaison est essentiellement la perception de l’observateur.

Pour réagir à l’article vous pouvez poster un message en suivant le lien en toute fin de page.

Cet article peut être librement diffusé et son contenu réutilisé pour une utilisation non commerciale (contacter l’auteur pour une utilisation commerciale) suivant la licence CC-by-nc-sa

Article

Introduction

L’utilisation d’outils numériques pour représenter des situations géométriques est chose commune à notre époque. Les possibilités de ces outils, notamment la facilité à changer de repère crée un nouveau type d’acteur dans l’expérimentation géométrique. Je l’appellerai « observateur ». C’est un nouveau rôle qui se distingue clairement de ceux en jeu dans la géométrie euclidienne étudiée avec règle et compas. Dans ce dernier cas [1], l’acteur est à la fois « facteur [2] » et « observateur ». Il ne peut y avoir pour lui de différence de géométrie des objets du point de vue de leur définition ou de leur perception.

Dans son article, François Goichot propose de tracer la représentation graphique d’une fonction en traçant des segments à l’aide du module turtle de Python. Il ne s’agit pas ici de discuter ce choix.
Le lecteur se reportera à l’article suffisamment clair et détaillé pour en apprendre plus. Il nous fournit ce module nommé tortue.py. Ce module inclut la fonction change_repere qui est une traduction de la fonction setworldcoordinates du module turtle originel.
Dans le document d’aide du module tortue, on peut lire :

change_repere(xmin, ymin, xmax, ymax) définit un nouveau repère : les abscisses iront de xmin à xmax (dans la fenêtre disponible) et les ordonnées de ymin à ymax (idem) ; il y a d’abord une mise à zéro ; ATTENTION, les angles seront déformés de manière imprévisible.

L’aide de Python fournit ceci :

turtle.setworldcoordinates(llx, lly, urx, ury)
Parameters:
   llx – a number, x-coordinate of lower left corner of canvas
   lly – a number, y-coordinate of lower left corner of canvas
   urx – a number, x-coordinate of upper right corner of canvas
   ury – a number, y-coordinate of upper right corner of canvas

Set up user-defined coordinate system and switch to mode “world” if necessary.
This performs a screen.reset().
If mode “world” is already active, all drawings are redrawn according to the new
coordinates.

ATTENTION: in user-defined coordinate systems angles may appear distorted.

Cette dernière mise en garde appelle plusieurs questions : comment et pourquoi les angles sont-ils modifiés ? Est-ce réellement imprévisible ? Quelle perception est induite pour l’observateur ?

Analyse dans le module turtle de Python

Pour illustrer ce phénomène, nous allons commencer par faire dessiner à la tortue Python un triangle équilatéral.
Nous utilisons le module turtle en mode console avec Python 3.5 [3] . Ainsi chacun pourra constater les effets en testant dans son environnement.
Sans entrer dans les détails de la programmation orientée objet, j’apporte quelques précisions :

  • Le choix suivant a été fait : importer le module turtle entier sans alias et sans importer les fonctions et classes du module.
  • De ce fait chaque appel à une fonction du module doit être préfixé par « turtle. ». L’appel d’une méthode de classe (fonction propre à une classe d’objet) se fait en préfixant par le nom de l’objet.

Ces choix sont motivés non pas par une transposition facilitée à une activité à faire avec les élèves, mais pour permettre au lecteur d’avoir une meilleure compréhension des éléments manipulés par le programmeur.

  1. >>> import turtle # on importe le module turtle
  2. >>> scene=turtle.Screen() # on crée la fenêtre graphique
  3. >>> scene.setup(width=480,height=320) # on modifie les dimensions de la fenêtre

Télécharger

image1

Nous voilà avec une aire de jeux prête à accueillir la tortue. Donnons lui une existence.

  1. >>> caroline=turtle.Turtle()

Une flèche représentant la tortue « caroline [4] » apparaît au centre de la fenêtre.

  1. >>> caroline.forward(100)
  2. >>> caroline.left(120)
  3. >>> caroline.forward(100)
  4. >>> caroline.left(120)
  5. >>> caroline.forward(100)
  6. >>> caroline.left(120)

Télécharger

Après lui avoir demandé d’exécuter les mouvements ci-dessus, on obtient la fenêtre suivante :

PNG - 7.5 ko
Figure 1
La tortue a dessiné un triangle équilatéral.

L’utilisateur expert en fenêtres que nous sommes ne peut s’empêcher de modifier la taille de la fenêtre. Par exemple, l’observateur peut obtenir en modifiant à la souris :

PNG - 7.4 ko
Figure 2
La taille de la fenêtre a été modifiée. Le dessin reste identique.

Le dessin n’est pas modifié et « caroline » se trouve toujours au centre de la fenêtre.
Analysons l’effet de la fonction setworldcoordinates. Cette fonction prend quatre arguments.
Les deux premiers représentent les coordonnées dans le nouveau repère du coin inférieur gauche de la fenêtre. Les deux derniers représentent les coordonnées dans le nouveau repère du coin supérieur droit de la fenêtre.

L’effet de la fonction dépend de la forme (dimensions) de la fenêtre au moment de son exécution.
En ce sens le changement de repérage induit des changements que le programmeur [5] ne peut prévoir.
On commence par rétablir les dimensions initiales de la fenêtre, puis on change le système de coordonnées.

  1. >>> scene.setup(width=480,height=320)
  2. >>> turtle.setworldcoordinates(-200,-200,200,200)

Télécharger

On peut voir [6] déjà l’effet du changement de repère. Pour se convaincre, on demande à « caroline » de refaire le dessin depuis le départ.

  1. >>> caroline.reset()# mise à zéro du graphique.
  2. >>> caroline.forward(100)
  3. >>> caroline.left(120)
  4. >>> caroline.forward(100)
  5. >>> caroline.left(120)
  6. >>> caroline.forward(100)
  7. >>> caroline.left(120)

Télécharger

PNG - 7.4 ko
Figure 3
La fenêtre a été modifiée. Le dessin du triangle équilatéral semble curieux.

À la question : « Quelle est la nature du triangle ? », je doute que l’on réponde de but en blanc « équilatéral ». Pourtant c’est bien un triangle équilatéral qui a été tracé. « caroline » en est convaincue car le changement de coordonnées n’a pas d’effet sur elle, mais sur l’observateur extérieur. Ce que « caroline » perçoit est juste un changement de forme de son aire de jeux qui devient un carré de 400 unités de large.
Pour l’utilisateur standard, la taille de la fenêtre reste identique et est un rectangle de 480 pixels de large pour 320 pixels de haut. Les résultats des deux commandes ci-après en témoignent.

  1. >>> scene.window_width()
  2. 480
  3. >>> scene.window_height()
  4. 320

Télécharger

L’avertissement du document d’aide est donc justifié et le changement de taille de fenêtre par l’utilisateur standard a des effets difficiles à anticiper pour le programmeur.
En effet le changement simple de dimensions de la fenêtre de manière graphique ou à l’aide d’une ligne de commande ne réduit pas l’écart de perception entre « caroline » et nous.

  1. >>> scene.setup(width=400,height=400)

La commande ci-dessus produit ceci :

PNG - 8.1 ko
Figure 4
La fenêtre de forme carrée [1].

[1On note l’apparition des ascenseurs.

Il faut de nouveau invoquer la commande suivante :

  1. >>> turtle.setworldcoordinates(-200,-200,200,200)

pour rétablir une perception conforme [7] du monde dans lequel vit « caroline ».

PNG - 7.6 ko
Figure 5
Fenêtre de forme carrée, jeu de coordonnées modifié.

Un peu de mathématiques

Comme nous l’avons vu précédemment, les changements d’angles ne sont que des changements de perception des angles par l’observateur de la fenêtre. Les angles n’ont pas changé dans le monde où vit « caroline ».
Dans cet exemple quelles sont les mesures des angles perçus par l’observateur de la fenêtre ?
Tout d’abord intéressons nous au changement de repère. La fonction setworldcoordinates induit le changement de repère suivant décrit par les changements de coordonnées de deux [8] points. Ainsi les images des coins inférieur gauche et supérieur droit suffisent à déterminer l’application affine de changement de repère.
Appelons A le coin inférieur gauche et B le coin supérieur droit.
Nous proposons les commandes [9] suivantes :

  1. >>> import turtle
  2. >>> scene=turtle.Screen()
  3. >>> scene.setup(width=480,height=320)
  4. >>> caroline=turtle.Turtle()

Télécharger

La fenêtre a une largeur de 480 pixels et une hauteur de 320 pixels. L’origine du repère est par défaut au centre de la fenêtre [10] .

Cela donne pour les coordonnées dans le repère initial :

$$\text{A}\left(\begin{array}{c}-240\\-160\end{array}\right)\text{ et }\text{B}\left(\begin{array}{c}240\\160\end{array}\right).$$

  1. >>> turtle.setworldcoordinates(-100,-150,300,250)

Le changement de repère a eu lieu. L’observateur perçoit un changement de position de « caroline ». On rappelle qu’aucune commande de déplacement ne lui a été transmise.
Cela donne pour les coordonnées dans le nouveau repère :

$$\text{A’}\left(\begin{array}{c}-100\\-150\end{array}\right)\text{ et }\text{B’}\left(\begin{array}{c}300\\250\end{array}\right).$$

Le centre [11] de la fenêtre dans ce nouveau repère est placé en $\text{O’}\left(\begin{array}{c}\frac{-100+300}{2}\\\frac{-150+250}{2}\end{array}\right)$.

Pour s’en convaincre demandons à caroline de rejoindre ce point :

  1. >>> caroline.goto(100,50)

Demandons lui de dessiner un carré :

  1. >>> caroline.reset() # retour au point de départ (0,0), effacement des traces
  2. >>> caroline.penup() # lève le crayon
  3. >>> caroline.goto(100,50) # se dirige vers le centre de la fenêtre
  4. >>> caroline.pendown() # baisse le crayon
  5. >>> for i in range(4):
  6. ... caroline.forward(100)
  7. ... caroline.left(90)
  8. ...

Télécharger

Le résultat peut paraître décevant pour l’observateur. « caroline » a quant à elle toutes les raisons d’être satisfaite. Elle a bel et bien tracé un carré.

PNG - 7 ko
Figure 6
Le carré de « caroline ».

Précisons la matrice associée au changement de repère. Il correspond à la matrice composée des vecteurs de la nouvelle base de l’espace vectoriel sous jacent dans les coordonnées relatives à l’ancienne base.
Notons $f$ l’application affine de changement de repère, $\vec{f}$ l’application linéaire associée.

On a :

$$\overrightarrow{f(\text{A})f(\text{B})}=\vec{f}(\overrightarrow{\text{A}\text{B}})$$

$$ \left( \begin{array}{c} 400\\ 400 \end{array} \right) = \left( \begin{array}{cc} m_{11}&0\\ 0&m_{22} \end{array} \right) \left( \begin{array}{c} 480\\ 320 \end{array} \right) $$

Ce qui donne, dans notre cas la matrice de changement de base : $\left( \begin{array}{cc} \frac{5}{6}&0\\ 0&\frac{5}{4} \end{array} \right)$

Les nouvelles coordonnées $(x’,y’)$ d’un point noté M d’anciennes coordonnées $(x,y)$ sont données ainsi :

$$ \left( \begin{array}{c} x’\\ y’ \end{array} \right) = \left( \begin{array}{cc} \frac{5}{6}&0\\ 0&\frac{5}{4} \end{array} \right) \left( \begin{array}{c} x\\ y \end{array} \right) +\left( \begin{array}{c} 100\\ 50 \end{array} \right) $$

Le passage des nouvelles coordonnées aux anciennes est aisé :

$$ \left( \begin{array}{c} x\\ y \end{array} \right) = \left( \begin{array}{cc} \frac{6}{5}&0\\ 0&\frac{4}{5} \end{array} \right) \left( \begin{array}{c} x’\\ y’ \end{array} \right) -\left( \begin{array}{c} 120\\ 40 \end{array} \right) $$

Les coordonnées des sommets du carré tracé par caroline sont : $(100 ;50)$, $(200 ;50)$, $(200 ;250)$, $(100 ;250)$.

Si on cherche les anciennes coordonnées des sommets du carré (celles perçues par l’observateur), on obtient :

$(0 ;0)$, $(120 ;0)$, $(120 ;80)$, $(120 ;80)$.

Il devient clair que l’observateur ne perçoit pas un carré. Il perçoit un rectangle de 120 pixels de large par 80 pixels de haut.

Si nous voulons que caroline dessine un carré selon l’observateur, nous pouvons le faire. Il suffit de lui transmettre les coordonnées des sommets dans son repère.

Prenons un carré de centre le centre de la fenêtre et de longueur de côté 48 [12]. Les coordonnées pour l’observateur sont $(-24 ;-24)$, $(24 ;-24)$, $(24 ;24)$, $(24 ;-24)$.

Les coordonnées à transmettre à caroline seront : $(80 ;20)$, $(120 ;20)$, $(120 ;80)$, $(80 ;80)$.

  1. >>> caroline.reset() # retour à la case départ (0,0), effacement des traces
  2. >>> caroline.penup() # lève le crayon
  3. >>> caroline.goto(80,20)
  4. >>> caroline.pendown() # baisse le crayon
  5. >>> caroline.goto(120,20)
  6. >>> caroline.goto(120,80)
  7. >>> caroline.goto(80,80)
  8. >>> caroline.goto(80,20)

Télécharger

PNG - 7 ko
Figure 7
Un carré pour l’observateur...

L’observateur est satisfait, mais « caroline » connaît la vérité sur la figure qu’elle vient de tracer : ce n’est pas un carré.

Revenons désormais au problème initial. Comment sont perçus les angles du triangle équilatéral du monde de « caroline » par l’observateur ?

On considère les trois sommets R, S et T du triangle. Exprimons leurs coordonnées dans le repère de « caroline » :

R$(100 ;50)$, S$(200 ;50)$, T$(150 ;50+50\sqrt{3})$.

  1. >>> caroline.reset()
  2. >>> caroline.penup()
  3. >>> caroline.goto(100,50)
  4. >>> caroline.pendown()
  5. >>> for i in range(3):
  6. ... caroline.forward(100)
  7. ... caroline.left(120)

Télécharger

donne le même résultat que :

  1. >>> caroline.reset()
  2. >>> caroline.penup()
  3. >>> caroline.goto(100,50)
  4. >>> caroline.pendown()
  5. >>> caroline.goto(200,50)
  6. >>> caroline.goto(150,50+50*3**0.5)
  7. >>> caroline.goto(100,50)

Télécharger

Les coordonnées perçues par l’observateur sont :

R$\left(0 ;0\right)$, S$\left(120 ;0\right)$, T$\left(60 ;40+40\sqrt{3}\right)$.

Les coordonnées de $\overrightarrow{\text{RS}}\left(120 ;0\right)$ et $\overrightarrow{\text{RT}}\left(60 ;40+40\sqrt{3}\right)$

Le calcul de l’angle $\widehat{\text{SRT}}$ se fait à l’aide d’un arccosinus :

$$\widehat{\text{SRT}}=\arccos\left(\dfrac{\overrightarrow{\text{RS}}\cdot\overrightarrow{\text{RT}}}{\Vert\overrightarrow{\text{RS}}\Vert\times\Vert\overrightarrow{\text{RT}}\Vert}\right) $$

On trouve après calcul [13] : $\widehat{\text{SRT}}\approx 49,1^{\circ}$.

Dans d’autres logiciels. . .

Ce phénomène n’est pas lié spécifiquement à Python ou encore au module turtle, mais plutôt à une adaptation plus ou moins automatique à la fenêtre de vue de l’observateur. Cette sorte d’autozoom peut s’avérer surprenant dans certains cas, inattendu dans d’autres :

Voici un exemple [14] traité avec GeoGebra [15].

PNG - 57.5 ko
Figure 8
Figure GeoGebra (vue standard)

Après un clic droit et « Recadrer », on obtient :

PNG - 64.3 ko
Figure 9
Figure GeoGebra (vue recadrée)

Les outils de mesures confirment la nature des objets :

PNG - 76.5 ko
Figure 10
Figure GeoGebra avec mesures (vue recadrée)

Ce n’est pas un défaut de GeoGebra qui serait pointé ici, mais plutôt l’illustration d’une fonctionnalité utile pour la représentation des fonctions, mais pouvant gêner l’observateur dans une activité de géométrie euclidienne.

Revenons donc au problème évoqué par François Goichot dans son article (Python et les graphes de fonctions). À savoir la représentation d’une fonction et le changement de repère permettant une meilleure visualisation du graphique. La fonctionnalité recadrer peut être un atout ici.

Voici deux illustrations d’une vue d’un graphique de fonction :

PNG - 50 ko
Vue standard
PNG - 54 ko
Vue après avoir cliqué droit puis sur « Recadrer »

La présence du repère est d’une aide précieuse [16] pour l’observateur. La différence de conception de GeoGebra et du module turtle de Python apparaît plus nettement. L’observateur agit directement sur la vue et le repère dans ce logiciel.

Cette fonctionnalité est déjà présente depuis de nombreuses années dans les calculatrices graphiques. On veut représenter graphiquement la fonction $x\longmapsto 2x^{2}-3x+1$. Cette fois-ci, l’observateur ne peut pas modifier [17] la taille de la fenêtre d’affichage.

Pour illustrer, j’utilise le simulateur en ligne de la Numworks [18].

PNG - 199.9 ko
options de base
PNG - 196.4 ko
fenêtre limitée par x ∈ [−5, 5] et y ∈ [−5, 5]
PNG - 197.8 ko
repère orthonormé

Ce qui diffère entre les trois vues est le repère. Ce changement de repère s’effectue avec des commandes analogues à celles de setworldcoordinates présentée plus tôt. Le fait que les axes du repère s’affichent à l’écran, ce dernier restant de taille fixe, permet à l’utilisateur de comprendre qu’un changement de repère a eu lieu et de l’appréhender correctement.

Des cas plus extrêmes ne permettent pas non plus l’affichage immédiat du repère ou de la fonction, mais sortent du cadre de la comparaison avec les outils précédents dont le module turtle de Python.

Voici deux exemples que j’emprunte à Benjamin. Dans ces exemples un affichage d’un graphique compréhensible nécessite un travail d’analyse mathématique. La question du contrôle a priori des résultats d’un logiciel ou procédé technologique se pose donc pleinement et les mathématiques ont ici toute leur place et validité.

$$x\longmapsto 100(x-20)^{2}-100$$

PNG - 197.6 ko
Affichage par défaut
PNG - 199.7 ko
Après zoom et déplacement du repère

$$x\longmapsto \sqrt{(x-20)}$$

PNG - 193.6 ko
Affichage par défaut
PNG - 194.2 ko
Après zoom et déplacement du repère

D’autres façon de voir, de concevoir et de percevoir

Scratch et GeoTortue

Scratch [19] propose une interface graphique ou espace de déplacement fixe avec un repère fixe. Il consiste en une scène de 480 pixels de large et de 320 pixels de haut munie d’un repère orthonormé centré.

De fait, Il n’y a pas de changements perceptifs possibles. L’utilisateur, la scène et le lutin « vivent » dans le même environnement.

De même avec GéoTortue [20], dans un usage classique, on retrouve quelque chose d’analogue avec la différence que l’espace graphique peut être modifié à partir des préférences. Cette modification n’a pas d’incidence sur le système de coordonnées utilisé par la tortue et la perception de ce dernier par l’observateur.

DGpad

Suite à des discussions avec des membres du comité de rédaction, ainsi que des expérimentations personnelles, j’ai voulu faire également un détour vers DGpad [21].

Ce logiciel est intéressant à plus d’un titre [22].

Ce qui m’intéresse ici c’est le changement perceptif entre le logiciel et l’utilisateur. En particulier le module Blockly intégré permet la programmation d’une tortue (animal décidément très cher à nos yeux).

Le choix de conception est le suivant : restreindre les possibilités de vision de l’observateur à la vision classique de géométrie euclidienne (le repère reste orthonormé). À la différence de GeoGebra il n’y a pas de changement perceptif induit par un autozoom sur les objets créés.

A priori il n’y a pas de raisons particulières pour voir des déformations d’angles comme observées dans la partie Analyse dans le module turtle. C’est ce qu’on constate.

En revanche il y a d’autres changements perceptifs en jeu qu’il me semble important d’évoquer.

La perception du temps

Dans le module blockly de DGpad, la perception du temps n’existe quasiment pas pour l’observateur. La tortue DGpad réalise de manière instantanée (pour l’observateur) les tracés de figures programmés. Cette non-perception du temps et donc du déroulement des séquences d’instructions est une référence didactique à prendre en compte pour élaborer des scénarii pédagogiques utilisant la programmation visuelle de DGpad (Blockly/Tortue).

PNG - 68.9 ko
Figure 11
Une spirale réalisée avec une tortue attachée au point P1

Dans la figure ci-dessus l’exécution du script Blockly se fait de manière quasi instantanée. L’observateur ne peut percevoir le déroulement des séquences d’instructions. Seule l’analyse combinée du script et de la figure obtenue permet de comprendre les enchaînements d’instructions.

Concurrence des unités

L’effet zoom (accessible depuis la molette sur ordinateur ou par un pincement sur tablette) induit un changement perceptif attendu et non problématique, à savoir un effet sur la perception des objets.

Comme le repère (plus précisément le système de coordonnées) reste orthonormé, on n’observe pas de déformation des angles lors de cette action, mais seulement un agrandissement ou réduction des longueurs.

PNG - 33.5 ko
Triangle et cercle
PNG - 40.8 ko
Triangle et cercle après un zoom

Par contre si les objets sont obtenus comme résultat d’un algorithme de tracé du module Blockly/Tortue, on observe des phénomènes particuliers liés au choix des unités de longueur.
Voici un exemple que chacun peut manipuler [23].

PNG - 102.2 ko
Vue du script Blockly/Tortue dans DGpad
Réalisation de trois triangles équilatéraux avec la tortue. Deux unités de longueur différentes sont utilisées.

Conclusion

Pour ce qui est de l’utilisation du module turtle la fonction setworldcoordinates provoque des effets sur le graphique qui peuvent être mal compris et mal appréhendés. Des logiciels grapheurs tels que GeoGebra ou le tracé de graphique par une calculatrice scientifique présentent la même fonctionnalité pour l’utilisateur d’adapter la vue à la fenêtre d’affichage. La différence se fait sur la perception de l’observateur. Pour les deux derniers, une possibilité d’accéder facilement au repère courant est un avantage que l’observateur habitué peut trouver normal, mais qui n’est plus automatique dès qu’on utilise des systèmes où beaucoup d’éléments sont à fournir. Dans le cas du module turtle, le repère est un élément dont il faudrait avoir une méthode de construction pour l’utiliser de manière plus sereine.

Une alternative à l’utilisation de la fonction setworldcoordinates serait d’effectuer le changement de coordonnées dans le programme principal pour un affichage correct (en s’assurant de garder un repère orthonormé par exemple pour la partie géométrie euclidienne, adaptée aux données pour la représentation graphique de fonctions). Le développement d’un tel outil complique énormément la programmation du tracé d’une représentation graphique d’une fonction et n’impacte pas sensiblement sa représentation, pas plus que la perception de l’observateur.

Il paraît donc plus utile de développer une fonction traçant le repère à l’aide du module turtle [24].

Ces remarques semblent dépasser les compétences visées par les programmes de mathématiques en terme algorithmique et programmation. Par contre je pense qu’il est commun de rencontrer ce type de situations et même d’autres effets parfois inattendus. Dans ce cas une bonne appréhension du problème lié à l’affichage et à la perception de cet affichage ainsi qu’une sensibilisation sur l’analyse a priori des outils numériques utilisés seront utiles aux enseignants.

Annexes

Utilitaire Python/Turtle

Dans cette annexe vous trouverez une proposition pour tracer un repère dans la fenêtre courante crée avec le module turtle.

Ce module peut être importé.

Si rendu exécutable, le script donne :

PNG - 8.1 ko
Figure 12
Fenêtre de fin de script (programme principal)

Voici le script python carolinerepere.py

  1. #!/usr/bin/python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. #
  5. # carolinerepere.py
  6. #
  7. # Illustration de l'usage du module tortue de Python pour afficher
  8. # une fenêtre repérée.
  9. #
  10. # module importé : turtle : import turtle
  11. # fonctions du module :
  12. # repere(xmin,xmax,ymin,ymax,gradx,grady,tortue)
  13. #
  14. #"""
  15.  
  16.  
  17. import turtle
  18.  
  19.  
  20. def repere(xmin,xmax,ymin,ymax,gradx,grady,tortue):
  21. """repere(xmin,xmax,ymin,ymax,gradx,grady,tortue)
  22. cette fonction utilise une tortue déjà présente et lui fait tracer un repère
  23. conforme aux paramètres transmis.
  24. il est possible d'effacer le repère produit lorsqu'on invoque la méthode
  25. clear() de la tortue considérée dans le programme principal.
  26.  
  27. Si O n'appartient pas à l'intervalle [xmin;xmax]
  28. L'axe des ordonnées n'est pas tracé
  29. Si O n'appartient pas à l'intervalle [ymin;ymax]
  30. L'axe des ordonnées n'est pas tracé"""
  31. #axe des abscisses
  32. if (0>ymin) and (0<ymax) :
  33. tortue.penup()
  34. tortue.goto(xmin,0)
  35. tortue.pendown()
  36. tortue.goto(xmax,0)
  37. tortue.penup()
  38. N1=int(xmin/gradx)
  39. N2=int(xmax/gradx)+1
  40. for i in range(N1,N2):
  41. tortue.goto(i*gradx,0)
  42. tortue.pendown()
  43. tortue.goto(i*gradx,-(ymax-ymin)*0.02)
  44. tortue.penup()
  45. if i==1:
  46. tortue.goto(i*gradx,-(ymax-ymin)*0.06)
  47. tortue.write(i*gradx,align="center")
  48. #axe des ordonnees
  49. if (0>xmin) and (0<xmax) :
  50. tortue.penup()
  51. tortue.goto(0,ymin)
  52. tortue.pendown()
  53. tortue.goto(0,ymax)
  54. tortue.penup()
  55. N1=int(ymin/grady)
  56. N2=int(ymax/grady)+1
  57. for i in range(N1,N2):
  58. tortue.goto(0,i*grady)
  59. tortue.pendown()
  60. tortue.goto(-(xmax-xmin)*0.02,i*grady)
  61. tortue.penup()
  62. if i==1:
  63. tortue.goto(-(xmax-ymin)*0.02,i*grady)
  64. tortue.write(i*grady,align="center")
  65.  
  66. if __name__ == '__main__':
  67. scene=turtle.Screen()
  68. scene.setup(width=600,height=400)
  69. turtle.setworldcoordinates(-5.1,-5.1,5.1,5.1)
  70. joe=turtle.Turtle()# tortue dédiée au tracé du repère
  71. repere(-5,5,-5,5,1,1,joe)
  72. joe.hideturtle()
  73. caroline=turtle.Turtle()
  74. caroline.penup()
  75. caroline.goto(-1,-1)
  76. caroline.color("blue")
  77. caroline.pendown()
  78. for i in range(4):
  79. caroline.forward(3)
  80. caroline.left(90)
  81. # la fenêtre ne se ferme que si l'observateur clique dessus.
  82. turtle.exitonclick()

Télécharger

On peut créer un script important le module. L’exécution de ce script illustre le tracé dans une fenêtre avec un jeu de coordonnées inadapté pour l’observateur. Une correction des dimensions de la fenêtre, puis un nouveau jeu de coordonnées rétablit une perception correcte des objets géométriques tracés.

Voici un premier script carolinetest.py :

  1. #!/usr/bin/python3
  2. # -*- coding: utf-8 -*-
  3.  
  4. from carolinerepere import *
  5.  
  6.  
  7. if __name__ == '__main__':
  8. scene=turtle.Screen()
  9. scene.setup(width=600,height=400)
  10. turtle.setworldcoordinates(-5.1,-5.1,5.1,5.1)
  11. jack=turtle.Turtle()
  12. jack.hideturtle()
  13. repere(-5,5,-5,5,1,1,jack)
  14. caroline=turtle.Turtle()
  15. caroline.penup()
  16. caroline.goto(-1,-1)
  17. caroline.color("blue")
  18. caroline.pendown()
  19. for i in range(4):
  20. caroline.forward(3)
  21. caroline.left(90)
  22. caroline.color("red")
  23. for i in range(3):
  24. caroline.forward(3)
  25. caroline.left(120)
  26. caroline.color("green")
  27. caroline.left(90)
  28. for i in range(3):
  29. caroline.forward(3)
  30. caroline.left(120)
  31. # changement de la fenêtre observateur
  32. scene.setup(width=600,height=600)
  33. # adaptation du jeu de coordonnées aux nouvelles dimensions
  34. turtle.setworldcoordinates(-5.1,-5.1,5.1,5.1)
  35. # la fenêtre ne se ferme que si l'observateur clique dessus.
  36. turtle.exitonclick()

Télécharger

PNG - 10.5 ko
Figure 13
Fenêtre de fin de script carolinetest.py

Voici un deuxième script carolinetestfonction.py qui complète la démarche de François Goichot dans son article.

  1. #!/usr/bin/python3
  2. # -*- coding: utf-8 -*-
  3.  
  4. from carolinerepere import *
  5.  
  6. def g(x):
  7. '''la fonction qu'on veut représenter'''
  8. return(2*x*x-3*x+1)
  9.  
  10. def h(x):
  11. '''la fonction qu'on veut représenter'''
  12. return(2*x+1)
  13.  
  14. def dessin(f,a,b,n,tortue):
  15. '''fait dessiner par tortue l'approximation affine
  16. par morceau du graphe de f obtenu en reliant les
  17. points (xi,f(xi)) sur [a,b] avec un nombre n+1 de points'''
  18. tortue.penup()
  19. pas=(b-a)/n
  20. for i in range(n):
  21. tortue.goto(a+i*pas,f(a+i*pas))
  22. tortue.pendown()
  23. tortue.goto(a+(i+1)*pas,f(a+(i+1)*pas))
  24. tortue.penup()
  25.  
  26.  
  27.  
  28. if __name__ == '__main__':
  29. scene=turtle.Screen()
  30. scene.setup(width=600,height=400)
  31. turtle.setworldcoordinates(-5.1,-5.1,5.1,5.1)
  32. joe=turtle.Turtle()
  33. joe.hideturtle()
  34. repere(-5,5,-5,5,1,1,joe)
  35. caroline=turtle.Turtle()
  36. caroline.hideturtle()
  37. caroline.color("blue")
  38. dessin(g,-4,3,30,caroline)
  39. scene.setup(width=600,height=600)
  40. turtle.setworldcoordinates(-3.1,-1.1,7.1,10.1)
  41. joe.clear()
  42. joe.color("purple")
  43. repere(-3,7,-1,10,1,1,joe)
  44. caroline.color("brown")
  45. dessin(h,-1,5,2,caroline)
  46. turtle.setworldcoordinates(-5.1,-4.1,5.1,40.1)
  47. joe.clear()
  48. repere(-5,5,-5,40,1,2,joe)
  49. # la fenêtre ne se ferme que si l'observateur clique dessus.
  50. turtle.exitonclick()

Télécharger

PNG - 8.8 ko
Figure 14
Fenêtre à l’issue de la ligne 38
PNG - 10 ko
Figure 15
Fenêtre à l’issue de la ligne 40
PNG - 11.5 ko
Figure 16
Fenêtre à l’issue de la ligne 45
PNG - 10.9 ko
Figure 17
Fenêtre à l’issue de la ligne 46
PNG - 11.1 ko
Figure 19
Fenêtre à l’issue de la ligne 48

Scripts DGPad


notes

[1Loin d’être démodé et heureusement encore largement pratiqué.

[2Il réalise la figure

[3Les commandes, l’utilisation du module turtle, les effets produits sont similaires avec Python 2.7.

[4J’ai choisi de passer directement à la lettre « C » et ainsi de rendre un petit hommage à ce personnage fort
sympathique présent dans les albums de Boule et Bill.

[5Dans un langage interprété tel que python, chacun passe d’un rôle programmeur à un rôle utilisateur simple. Ces deux rôles entrent ici en concurrence.

[6Au premier appel de la fonction setworldcoordinates tous les dessins sont effacés, pour les appels suivants, ils sont mis à jour.

[7Chaque pixel représente à nouveau une unité en abscisse et en ordonnée

[8Dans un changement de repère affine, trois points sont nécessaires. Ici ce n’est pas le cas car les vecteurs de bases
sont colinéaires aux anciens (la fenêtre reste un rectangle), la matrice de changement de base est diagonale.

[9Démarrer une nouvelle console ou réutiliser les objets déjà créés.

[10« caroline » se place à l’origine du repère une fois qu’elle est née.

[11C’est le milieu de [A’B’]

[12un multiple de 12 est plus commode pour les calculs

[13À vos calculettes...

[14Certaines leçons sur les coniques peuvent s’avérer croustillantes et fourniront d’autres cas intéressants.

[15version : GeoGebra 5.0.414.0-d (19 December 2017)

[16En fait indispensable.

[17Même si la Numworks permet à l’utilisateur d’apporter des modifications logicielles, elle ne lui permet pas encore de rajouter à l’écran des pixels dans l’une ou l’autre dimension...

[18Pour plus de renseignements sur cette calculatrice : https://www.numworks.com/fr/ .

[19Pour plus de renseignements sur cet environnement : https://scratch.mit.edu/

[20Pour plus de renseignements sur cet environnement : http://geotortue.free.fr/. Voir également : Géotortue : expérimentation en 5ème et pistes à explorer pour une récit d’expérimentation par Julien Pavageau.

[21Pour plus de renseignements sur le logiciel : https://www.dgpad.net/.

[22Voir les articles le concernant dans les colonnes de MathemaTICE

[23Cliquer sur le bouton. Ensuite avec l’outil flèche activé, cliquer sur le sommet commun au trois triangles. Faire apparaître le script Blockly.

[24En annexe je propose un module python ou une telle fonction est créée. Ce module n’est pas abouti, mais permet d’illustrer le propos.

Documents associés à l'article
  Figure DGpad   |  Trois triangles équilatéraux  |   (Zip - 2 ko)
Crédits : Aymeric Picaud
Réagir à cet article
Vous souhaitez compléter cet article pour un numéro futur, réagir à son contenu, demander des précisions à l'auteur ou au comité de rédaction...
À lire aussi ici
MathémaTICE est un projet
en collaboration avec
Suivre la vie du site Flux RSS 2.0  |  Espace de rédaction  |  Nous contacter  |  Site réalisé avec: SPIP  |  N° ISSN 2109-9197