Sauter au contenu
Logo image

Algèbre linéaire Intuition et rigueur

Jean-Sébastien Turcotte, Philémon Turcotte

Section 2.5 Activités et laboratoires

Dans cette section, on regarde des activités et des laboratoires en lien avec des concepts présentés dans le chapitre.
🔗

Projet 2.5.1. De l’art géométrique.

On a vu à l’exemple 2.1.22 qu’on pouvait appliquer une transformation à une liste de points. Dans ce projet, on souhaite créer une œuvre artistique à l’aide des transformations linéaires. Afin de bien comprendre, on divise le projet en deux étapes.
🔗

(a)

Le but de cette étape est de reproduire la figure ci-dessous à partir d’une liste de points initiaux.
🔗
Figure 2.5.1. Une belle étoile
🔗
(i)
La commande polygon permet de tracer un polygone à partir d’une liste de points. L’étoile de la figure 2.5.1 a été obtenue en utilisant également les options color="gold" et edgecolor="black". À partir de la liste de points suivants et d’une réflexion selon l’axe des \(y\text{,}\) créer la seconde moitié de l’étoile en arrière-plan (On peut utiliser la commande Listetransformees=[T*P for P in Listepoints] pour obtenir l’image par la transformation \(T\)).
🔗
🔗
(ii)
Pour créer la partie en avant-plan de l’étoile, on procède en deux étapes:
  1. Dans un premier temps, on applique à la liste des points initiaux une rotation de \(180^\circ\text{.}\)
    🔗
    🔗
  2. Pour l’autre partie, on applique la réflexion selon l’axe des \(y\) aux points après la rotation ci-dessus.
    🔗
    🔗
🔗
🔗
(iii)
En général, la composition d’une réflexion et d’une rotation n’est pas commutative, comme le montre l’exemple 2.2.17. Toutefois, dans ce cas-ci, la rotation et la réflexion le sont. Démontrer avec Sage que cette affirmation est exacte et utiliser ce fait pour obtenir la partie en avant-plan par une autre méthode que celle de l’étape 2.5.1.a.ii.
🔗
🔗
🔗

(b)

À partir d’une liste de points quelconques, créer un objet artistique. Les restrictions sont minimes, mais on demande au minimum:
  • un polygone créé à partir d’au moins huit points;
    🔗
    🔗
  • L’utilisation d’au moins deux transformations linéaires différentes.
    🔗
    🔗
🔗
Utiliser couleurs et autres options au choix. La page d’aide de Sage sur les polygones peut servir de sources d’inspiration que ce soit pour des idées de figures ou d’options: https://doc.sagemath.org/html/en/reference/plotting/sage/plot/polygon.html.
🔗
🔗
🔗

Projet 2.5.2. Anaglyphe.

Ce laboratoire est une adaptation sur Sage du projet “Anaglyphe et visualisation 3D”, disponible sur projetsmathematiquests.com, sous licence creative commons.
🔗
Le cerveau humain est capable de grandes choses. À partir d’images sur une feuille ou un écran, il est capable de percevoir de la profondeur et du relief. La stéréoscopie est l’ensemble des techniques mises en œuvre pour reproduire une perception de ce relief à partir d’images planes. Un anaglyphe est une paire d’images, chacune étant de la couleur complémentaire à l’autre, qui est regardée au travers d’un filtre. Chaque image représente la même figure, mais légèrement décalée. Le plus répandu des anaglyphes est celui où l’œil gauche est affecté d’un filtre rouge et l’œil droit d’un filtre cyan. Dans ce laboratoire, on construit, dans un premier temps, l’anaglyphe d’un objet commun, que l’on animera. Dans un deuxième temps, après s’être familiarisé avec la création, on construit une maquette, pouvant être composée de plusieurs objets.
🔗

(a)

Pour commencer, on choisit de construire un objet simple afin de bien comprendre le fonctionnement d’un anaglyphe et sa construction sur Sage. La commande line permet de relier une série de points, formant ainsi un objet connecté. On trace ensuite une ligne entre chaque point et le suivant dans la liste, jusqu’à l’avant-dernier point. Compléter la commande ci-dessous afin de construire une pyramide à base carrée dont les côtés mesurent \(2\) unités, centrée à l’origine et de hauteur $6$ unités. Il faudra répéter des points afin de produire un dessin complet.
🔗
Il est possible de déplacer le point de vue en manipulant la figure créée. Les options projection="orthographic",viewpoint=[[-1,-1,-1],120] ont été choisies afin qu’il n’y ait pas d’effet de perspective et pour que l’angle de vue par défaut soit celui correspondant au plan \(y\)-\(z\text{,}\) qui est l’écran de l’utilisateur dans le repère utilisé.
🔗
🔗

(b)

La projection sur l’écran de l’objet proposé n’est pas très intéressante à regarder, puisqu’il d’un triangle qui ne rend pas l’impression des trois dimensions. On s’imagine un repère dont l’origine est au centre de l’écran d’ordinateur. L’axe des \(x\) pointe vers l’utilisateur, entre ses deux yeux. L’axe des \(y\) et l’axe des \(z\) forment le plan représentant l’écran. On peut choisir de déplacer le point de vue, par rapport à ce repère, ou encore de transformer l’objet en utilisant des transformations linéaires ou des translations. La première option peut être effectuée en manipulant la figure ou en modifiant l’option viewpoint dans la command line. Dans le but d’explorer les transformations linéaires, on choisit la deuxième option. On va transformer l’objet en utilisant deux transformations linéaires ainsi qu’une translation. D’abord, on lui applique une rotation par rapport à l’axe des \(z\text{.}\) Par défaut, on choisit un angle de \(\frac{\pi}{4}\text{,}\) mais il sera possible de modifier cet angle plus tard. Ensuite, on applique une rotation par rapport à l’axe des \(y\text{,}\) d’un angle de \(\frac{\pi}{6}\) cette fois. Enfin, on termine avec une translation de \((5,0,0)\text{,}\) ce qui a pour effet d’amener l’objet « devant » l’écran. Compléter le code ci-dessous afin de transformer l’objet. Pour appliquer une ou plusieurs matrices à une liste d’objets, on peut utiliser la commande Pointstransformes=[T*P+t for P in Listepoints] où \(T\) est la combinaison des transformations linéaires et \(t\) est la translation.
🔗
🔗

(c)

Maintenant que l’objet est en place, dans une orientation intéressante, on le projette sur le plan à deux dimensions formé des axes \(y\) et \(z\text{.}\) Afin de créer les maquettes qui composent l’anaglyphe, on a le choix de le faire dans l’espace à trois dimensions ou de voir le plan \(y,z\) sur lequel les maquettes se trouvent comme une copie de \(\mathbb{R}^2\text{.}\) On choisit la deuxième option. Pour arriver à effectuer la projection, on doit établir la position de chacun des yeux de l’observateur. On rappelle que dans le repère, l’axe des \(x\) pointe en plein milieu des deux yeux de l’utilisateur. La composante \(x\) des deux yeux est donc la distance entre l’utilisateur et l’écran. Pour les composantes \(y\text{,}\) elles sont, respectivement pour l’œil gauche et l’œil droit, la moitié de la distance entre le centre des yeux de l’utilisateur. Finalement, la composante \(z\) des yeux est zéro. Compléter le code ci-dessous avec les mesures correspondantes.
🔗
🔗

(d)

Pour la première projection, on regarde l’œil gauche. Le côté gauche de la lunette est normalement monté d’un filtre rouge. Parmi les deux projections, l’œil gauche ne verra donc que l’objet cyan. On va créer la projection de l’objet sur l’écran telle que vue par l’œil gauche pour ensuite le colorer en cyan. Pour cela, on imagine une droite passant par l’œil gauche, situé au point \(G\text{,}\) et chacun des points \(P\) de l’objet. Cette droite intersecte le plan \(x\)-\(y\) en un point.
  1. Créer une fonction qui prend comme argument un paramètre $k$ et un point $P$ et qui retourne l’équation vectorielle de la droite passant par $G$ et $P$;
    🔗
    🔗
  2. Créer une liste qui, pour chaque point $P$, contient la valeur de $k$ nécessaire pour que le point sur la droite soit également sur le plan $y$-$z$;
    🔗
    🔗
  3. Créer la liste pointscyans contenant la liste des points projetés sur le plan $x$-$y$;
    🔗
    🔗
  4. Créer la maquette cyan
    🔗
    🔗
🔗
Pour chaque point \(P\text{,}\) on veut déterminer la valeur du paramètre \(k\) qui correspond au point sur le plan. On utilise la commande solve pour déterminer la valeur de \(k\text{.}\) Cette commande retourne une liste d’équations. Puisqu’on sait qu’il n’y aura qu’une solution à l’équation que l’on veut résoudre, on utilise [0] pour faire ressortir la première et seule équation et la commande .rhs() afin d’obtenir le côté droit de l’égalité, qui correspond à la valeur de \(k\text{.}\)
🔗
La commande zip permet de combiner deux listes en une seule en joignant les éléments correspondants. Par exemple, list(zip([1,2,3],[4,5,6])) produit la liste [(1,4),(2,5),(3,6)].
🔗
On utilise cette commande pour grouper les listes Pointstransformes et paramk.
🔗
La liste pointscyans est créée en allant chercher les bonnes composantes dans l’équation de la droite Dgauche(k,P) pour la valeur de \(k\) associée au point \(P\text{.}\) On cherche à obtenir une liste de listes. Chacune des listes intérieures représente les composantes de la projection d’un point $P$ sur le plan $y$-$z$ vue comme si elle était dans un espace à deux dimensions. Compléter la cellule ci-dessous.
🔗
Finalement, on crée la maquette cyan.
🔗
🔗

(e)

Pour la deuxième projection, on regarde l’œil droit. Le côté droit de la lunette est normalement monté d’un filtre cyan. Parmi les deux projections, l’œil droit ne verra donc que l’objet rouge. On va créer la projection de l’objet sur l’écran telle que vu par l’œil droit et le colorer en rouge. Pour cela, on imagine une droite passant par l’œil droit, situé au point \(D\text{,}\) et chacun des points \(P\) de l’objet. Cette droite intersecte le plan \(x\)-\(y\) en un point.
  1. Créer une fonction qui prend comme argument un paramètre \(k\) et un point \(P\) et qui retourne l’équation vectorielle de la droite passant par \(D\) et \(P\text{.}\)
    🔗
    🔗
  2. Créer une liste qui, pour chaque point \(P\text{,}\) contient la valeur de \(k\) nécessaire pour que le point sur la droite soit également sur le plan \(x\)-\(y\text{.}\)
    🔗
    🔗
  3. Créer la liste pointsrouges contenant la liste des points projetés sur le plan \(x\)-\(y\text{.}\)
    🔗
    🔗
  4. Créer la maquette rouge
    🔗
    🔗
🔗
🔗

(f)

Enfin, on veut afficher les deux morceaux de l’anaglyphe en un seul graphique.
🔗
🔗

(g)

Pour explorer davantage, on utilise Sage pour animer l’anaglyphe à l’aide de curseurs. Les curseurs permettent de modifier les angles des rotations, la translation choisie ainsi que les paramètres de distance avec l’écran et de distance entre les yeux. Pour cela, on utilise un interact, objet Sage permettant, entre autres, de créer des curseurs et de produire du contenu dynamique. Le squelette est fourni avec une partie à compléter. Le code commence par @interact, ce qui active le mode interactif de Sage. Ensuite, on définit la fonction `anaglyphe` dont les arguments sont un ensemble de curseurs (slider) et une boite d’entrée (input_box). Des valeurs par défauts sont fournies. Sous la ligne initialisant la fonction, on applique une commande Sage qui convertit la liste des points en objet Sage et l’on crée un graphique vide dans lequel on ajoutera l’anaglyphe. Compléter le code afin de créer l’application interactive.
🔗
🔗

(h)

La commande line relie tous les points d’une liste. Il peut être utile de privilégier des objets distincts afin de créer une maquette plus intéressante. La manière dont la fonction anaglyphe ci-dessus a été créée permet d’avoir plusieurs objets et de construire leur anaglyphe respectif. La fonction anaglype prend comme entrée un dictionnaire composé d’objets et leurs points. Dans la boite d’entrée, écrire {"cube":[[0, 0, 0],[1, 0, 0],[1, 1, 0],[0, 1, 0],[0, 0, 0],[0, 0, 1],[1, 0, 1],[1, 1, 1],[0, 1, 1],[0, 0, 1],[0, 1, 1],[1, 1, 1],[1, 1, 0],[1, 0, 0],[1, 0, 1],[0, 0, 1],[1, 0, 1],[1, 1, 1],[1, 1, 0],[0, 1, 0],[0, 1, 1]],"tetraedre":[[-1,-1,-1],[1,-1,-1],[0,1,-1],[-1,-1,-1],[0,0,2],[1,-1,-1],[0,0,2],[0,1,-1],[1,-1,-1],[0,1,-1],[0,0,2],[-1,-1,-1]]} afin de voir un cube et un tétraèdre en anaglyphe.
🔗
Créer un objet artistique. Les restrictions sont peu nombreuses, mais on demande au minimum une maquette composée d’au moins deux objets distincts, chacun formé d’au moins dix points.
🔗
🔗
🔗
🔗
PrécédentTopSuivant