TP_numpy_image_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP d'application de Numpy : traitement d'images\n",
    "\n",
    "Le but de ce TP est de se familiariser à numpy en appliquant les outils numpy au traitement d'image.\n",
    "A cette fin, on va utiliser des outils de visualisation, qu'on consiérera simplement comme des boîtes noires permettant de passer dans un sens ou dans un autre d'une image à un tableau numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import imread, imshow\n",
    "import numpy as np\n",
    "from numpy.random import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprendre ce qu'est une image\n",
    "\n",
    "Dans un premier temps quelques expérimentations pour comprendre comment une image est est représentée par un tableau numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "petit_damier = np.array([[0,1],[1,0]])\n",
    "imshow(petit_damier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imshow(petit_damier,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** : faire afficher un damier 8x8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "petit_damier = np.array([[0,1],[1,0]])\n",
    "damier = np.tile(petit_damier,[4,4])\n",
    "imshow(damier,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Afficher un damier $8\\times 8$ dont les cases sont coloriées de façon aléatoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mire = random([8,8,3])\n",
    "imshow(mire)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons maintenant télécharger une photo bien connue de tous ceux qui font du traitement d'images. Pour ceux qui voudraient en savoir plus au sujet de cette image : https://fr.wikipedia.org/wiki/Lenna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena = imread(\"http://optipng.sourceforge.net/pngtech/img/lena.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imshow(lena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardons comment est constitué l'objet python qui contient l'information de  l'image :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lena.shape, lena.dtype)\n",
    "print(lena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est temps de jeter un coup d'oeil sur la documentation des fonction `imread` et `imshow`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(imread)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(imshow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Représentation des images**\n",
    "\n",
    "Une image est une matrice dont les points sont appelés des pixels. Ainsi notre image test est une matrice de $512\\times 512$ pixels.\n",
    "- Si l'image est en niveaux de gris, chaque pixel est décrit par une intensité (suivant les codages, un nombre réel entre 0 et 1, ou un entier entre 0 et 255, ou ...)\n",
    "- Si l'image est en couleurs, chaque pixel est décrit par un triplet d'intensités (de rouge, vert, bleu dans le codage RVB)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les composantes monocolores d'une image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Exercice** \n",
    "\n",
    "Extraire les composantes rouge, vert et bleu de lena (chacune d'elles est un tableau 512x512).\n",
    "\n",
    "Pour obtenir une image en niveaux de gris, il est habituel de prendre une moyenne pondérée de ces trois composantes. Les coefficients sont choisis pour tenir compte au mieux de la sensibilité de l'oeil humain aux différentes couleurs :\n",
    "\n",
    "``` gris = 0.299*rouge + 0.587*vert +0.114*bleu ```\n",
    "\n",
    "A partir de la photo en couleur `lena`, fabriquez et affichez l'image en niveaux de gris correspondante, et faites-la afficher (pour un bon rendu, il faut choisir une colormap adéquate ; je conseille de mettre l'option `cmap=\"binary_r\"` )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena_r = lena[:,:,0]\n",
    "lena_v = lena[:,:,1]\n",
    "lena_b = lena[:,:,2]\n",
    "lena_gris = 0.299 * lena_r + 0.587 * lena_v + 0.114 * lena_b\n",
    "imshow(lena_gris,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on veut afficher la composante rouge de lena, il nous faut cette fois-ci construire un nouveau tableau 512x512x3, dont la composante rouge est celle de lena, et les deux autres sont nulles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena_R = np.zeros_like(lena)\n",
    "lena_R[:,:,0] = lena_r\n",
    "imshow(lena_R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** faire de même avec les autres composantes de couleur de l'image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena_V = lena.copy()\n",
    "lena_V[:,:,::2] = 0\n",
    "imshow(lena_V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena_B = lena.copy()\n",
    "lena_B[:,:,:2] = 0\n",
    "imshow(lena_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Négatif d'une image en niveaux de gris.\n",
    "Créer le négatif de la photo de Lena en niveaux de gris  (un pixel d'intensité $x$ est transformé en un pixel d'intensité $1-x$. Faites-le afficher en utlisant la colormap `binary_r`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lena_negatif = 1 - lena_gris\n",
    "imshow(lena_negatif, cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : on aurait pu obtenir le même affichage en affichant directement `lena_gris` avec la colormap `binary`, qui est la colormap inverse de `binary_r`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imshow(lena_gris, cmap=\"binary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Luminosité et contraste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour aumenter la luminosité d'une image en niveaux de gris, la solution la plus simple est de décaller tous les pixels d'un même coefficient $c$. Autrement dit, on applique au tableau une fonction $f_c:x\\mapsto x+c$, avec $c\\in [0,1]$. \n",
    "\n",
    "Le problème est que pour certains pixels, la valeur $x+c$ sera supérieure à 1. On doit donc modifier cette fonction en prenant :\n",
    "$f_c:x\\mapsto \\min(x+c,1)$.\n",
    "\n",
    "**Exercice :** Ecrire une fonction `augmente_luminosite(M,c)` qui effectue cette opération (on pourra utiliser la fonction `np.minimum`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def augmente_luminosite(M,c):\n",
    "    return np.minimum(c + M, 1)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester cette fonction en l'appliquant à  lena, avec différentes valeurs de $c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = lena_gris.copy()\n",
    "imshow(augmente_luminosite(M,0.2),cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le défaut de cette méthode est que les noirs profonds disparaissent et que les zones très éclairées se retrouvent saturées. Pour remédier à ceci, on peut envisager d'utiliser une fonction $f:[0,1]\\to[0,1]$ croissante bijective avec $f'(0)>1$ et $f'(1)=0$. Par exemple, on peut prendre $f(x) = x(2-x)$.\n",
    "\n",
    "**Exercice :** Ecrire une fonction `augmente_luminosite_2(M)` qui effectue cette opération."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def augmente_luminosite_2(M):\n",
    "    return M*(2-M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tester cette fonction en l'appliquant à lena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = lena_gris.copy()\n",
    "imshow(augmente_luminosite_2(M),cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi envisager d'augmenter le contraste de l'image. Pour cela, il s'agit de dilater l'intervalle des valeurs des pixels autour de 1/2 par un facteur multiplicatif $c$. Autement dit, on applique à l'image une fonction \n",
    "$f_c : x\\mapsto 1/2 + c(x-1/2)$. ($c$ est un réel supérieur à 1).\n",
    "\n",
    "**Exercice :** Ecrire une fonction `augmente_contraste(M,c)` qui effectue cette opération."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def augmente_contraste(M,c):\n",
    "    M = 0.5 + c*(M-0.5)\n",
    "    M = np.maximum(M,0)\n",
    "    M = np.minimum(M,1)\n",
    "    return M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez votre fonction avec différentes valeurs de $c$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = lena_gris.copy()\n",
    "imshow(augmente_contraste(M,1.4),cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Détection de contours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les contours d'une image sont les endroits où la variation d'intensité est la plus importante. Une façon de mesurer la variation d'intensité dans une image M de  taille $n\\times n$ est de construire une nouvelle matrice N de taille $(n-1)\\times(n-1)$, dont les coefficients sont \n",
    "$$\n",
    "N_{i,j} =\n",
    "\\sqrt{  (M_{i,j+1}-M{i,j} )^2 + (M_{i+1,j}-M{i,j} )^2 }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice** Faire afficher les contours du portrait de Lena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_vert = lena_gris[1:,:-1]-lena_gris[:-1,:-1]\n",
    "var_horiz = lena_gris[:-1,1:]-lena_gris[:-1,:-1]\n",
    "contour = np.sqrt(var_vert**2 + var_horiz**2)\n",
    "imshow(contour,cmap=\"binary\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Maintenant que vous avez réussi à appliquer cette transformation à la photo proposée, écrivez une fonction `contour(adresse)` qui prend en argument l'adresse d'une image  monocolore, et affiche ses contours. Appliquez-la à l'image de votre choix, trouvée sur le web."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contour(adresse):\n",
    "    M = imread(adresse)\n",
    "    var_vert = M[1:,:-1] - M[:-1,:-1]\n",
    "    var_horiz = M[:-1,1:] - M[:-1,:-1]\n",
    "    contour = np.sqrt(var_vert**2 + var_horiz**2)\n",
    "    imshow(contour,cmap=\"binary\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modification de la résolution et pixélisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir d'une image $2n \\times 2m$, on peut fabriquer une image $n\\times m$ : on remplace chaque carré $2\\times2$ de l'image initiale par un unique pixel dont la valeur  est la moyenne des 4 pixels du petit carré de l'image initiale. En faisant ça, on obtient une image de poids plus petit que l'image initiale, mais aussi on perd de l'information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Ecrire une fonction `reduction(M)`, prenant en argument une image en couleur, et rendant l'image obtenue par le procédé de réduction décrit plus haut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduction(M):\n",
    "    N = ( M[::2,::2,:] + M[1::2,::2,:] + M[::2,1::2,:] + M[1::2,1::2,:] ) /4\n",
    "    return N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appliquer plusieurs fois successivement cette opération à notre image `lena` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = reduction(lena)\n",
    "imshow(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "et si on répète l'opération :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = reduction(N)\n",
    "imshow(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = reduction(N)\n",
    "imshow(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = reduction(N)\n",
    "imshow(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit bien apparaitre le phénomène de pixélisation, qui apparaît quand on diminue trop fortement la résolution d'une image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Débruitage d'une image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va partir de l'image en niveau de gris, et lui appliquer un bruitage, en modifiant des pixels choisis aléatoirement.\n",
    "Le but de l'exercice sera de retouver une image décente à partir de l'image bruitée.\n",
    "\n",
    "On commence par écrire une fonction `bruitage(M,nb_pixels)` qui prend en argument une image monochrome et remplace la valeur de `nb_pixels` choisis aléatoirement par 1  (pixel blanc) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import randint\n",
    "def bruitage(M,nb_pixels):\n",
    "    N = M.copy()\n",
    "    l,m = N.shape\n",
    "    x = randint(0,l,nb_pixels)\n",
    "    y = randint(0,m,nb_pixels)\n",
    "    N[x,y] = 1\n",
    "    return N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig = lena_gris.copy()\n",
    "image_bruitee = bruitage(orig,2000)\n",
    "imshow(image_bruitee,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Votre mission est maintenant de rectifier cette image. Pour cela, écrivez une fonction `filtre(M,k)` prenant en argument une image monochrome et un entier $k$, et et rendant l'image obtenue en remplaçant chaque pixel par la moyenne des pixels du carré de taille $2k+1$ centré autour de ce pixel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filtre_moyenne(M,k):\n",
    "    N = M.copy()\n",
    "    l,m = M.shape\n",
    "    for i in range(k,l-k):\n",
    "        for j in range(k,l-k):\n",
    "            N[i,j] = np.mean(N[i-k:i+k+1,j-k:j+k+1])\n",
    "    return N\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appliquez votre filtre à l'image bruitée, avec $k=1$, et faites afficher l'image.\n",
    "Que donne ce filtre avec des valeurs de $k$ plus grandes ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = filtre_moyenne(image_bruitee,1)\n",
    "imshow(P,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Écrivez un filtre analogue `filtre_mediane(M,k)`, où on prend cette fois-ci la moyenne des $k^2$ pixels voisins d'un pixel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filtre_mediane(M,k):\n",
    "    N = M.copy()\n",
    "    l,m = M.shape\n",
    "    for i in range(k,l-k):\n",
    "        for j in range(k,l-k):\n",
    "            N[i,j] = np.median(N[i-k:i+k+1,j-k:j+k+1])\n",
    "    return N\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testez ce nouveau filtre sur l'image bruitée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = filtre_mediane(image_bruitee,1)\n",
    "imshow(P,cmap=\"binary_r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La transformation du photomaton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va transformer notre image couleur de taille 512x512 de base en construisant 4 images de taille 156x256 de la façon suivante\n",
    "\n",
    "- $M_{1,1}$ contient tous les pixels d'abscisse paire et d'ordonnée paire\n",
    "- $M_{2,1}$ contient tous les pixels d'abscisse impaire et d'ordonnée paire\n",
    "- $M_{1,1}$ contient tous les pixels d'abscisse paire et d'ordonnée impaire\n",
    "- $M_{2,1}$ contient tous les pixels d'abscisse impaire et d'ordonnée impaire\n",
    "\n",
    "et on construit une nouvelle matrice $N$ en juxtaposant ces 4 matrices\n",
    "\n",
    "$$\n",
    "N =\\left( \\begin{array}{cc} \n",
    "M_{1,1} & M_{1,2}\\\\\n",
    "M_{2,1} & M_{2,2}\n",
    "\\end{array} \\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :**  Construire une fonction `photomaton(M)` prenant en argument le tableau M et rendant le tableau N."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def photomaton(M):\n",
    "    N = np.zeros_like(M)\n",
    "    l,m = M.shape[0]//2, M.shape[1]//2\n",
    "    N[:l,:m,:] = M[::2,::2,:]\n",
    "    N[l:,:m,:] = M[1::2,::2,:]\n",
    "    N[:l,m:,:] = M[::2,1::2,:]\n",
    "    N[l:,m:,:] = M[1::2,1::2,:]\n",
    "    return N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question :** Que se passe-t-il si on itère 9 fois cette transformation à partir de la photo de Lena ?\n",
    "Savez-vous interpréter mathématiquement le phénomène que vous observez ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = photomaton(lena)\n",
    "imshow(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = photomaton(M)\n",
    "M = photomaton(M)\n",
    "M = photomaton(M)\n",
    "M = photomaton(M)  # cinquième itération\n",
    "imshow(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = photomaton(M)\n",
    "M = photomaton(M)  # septième itération\n",
    "imshow(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = photomaton(M)  # huitème itération\n",
    "imshow(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = photomaton(M)  # et voilà la neuvième itération\n",
    "imshow(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit qu'à la neuvième itération on récupère l'image initiale. La transformation du photomaton réalise une permutation $\\sigma$ de l'ensemble des $512\\times512$ pixels de l'image. La question est alors de prouver mathématiquement que $\\sigma^9 = \\text{Id}$."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}